The End of Code: Why Specifications Are Eating Software

💡 TL;DR - The 30 Seconds Version

👉 OpenAI's Sean Grove says writing specifications beats writing code, while AWS launches Kiro to turn prompts into technical specs automatically.

📊 Grove argues coding is only 10-20% of development work, while 80% is structured communication that AI handles poorly.

🏭 GeneXus claims they've used specification-driven development for 35 years with deterministic generators, not AI models.

🌍 OpenAI's Model Spec proves the concept by using English specifications to train models and fix problems like sycophancy.

💰 Kiro offers 50 free interactions monthly, then $19 for 1,000 interactions, positioning against "vibe coding" tools.

🚀 This shift makes specifications the new source code, with traditional coding becoming just implementation details.

Sean Grove from OpenAI stood before a room full of developers and said something that should have caused a riot: "The person who communicates most effectively is the most valuable programmer." He wasn't talking about Slack messages or standups. He was talking about the death of code itself.

Grove's vision, outlined in his talk "The New Code," flips 70 years of software development on its head. Instead of writing code to solve problems, we should write specifications that generate code. It's like the difference between hammering nails yourself and drawing blueprints that machines build for you.

This sounds crazy, but it's already here. AWS just launched Kiro, an IDE that turns casual prompts into detailed technical specifications. Type "Add a review system for products" and Kiro spits out user stories, API endpoints, database schemas, and implementation tasks. Code becomes the byproduct, not the goal.

The Specification Revolution

Grove's argument is simple: most of what developers do isn't actually coding. It's talking to users, understanding problems, planning solutions, and testing results. The actual typing of code? That's maybe 10-20% of the work. The other 80% is structured communication.

This matters because AI models are getting scary good at the typing part. Claude can write React components. GPT-4 can debug Python. But they're terrible at understanding what you actually want. That's where specifications come in.

A good specification captures intent, not just instructions. It says why you need something, how it should work, and when you're done. Code just implements one possible solution. Specifications can generate multiple solutions—web apps, mobile apps, APIs, documentation, even podcasts explaining how to use the thing.

The Kiro Test Case

AWS clearly got the memo. Kiro takes Grove's philosophy and builds an entire development environment around it. Instead of starting with empty files, you start with prompts. Instead of writing code first, you write specifications first.

The system works in three phases. First, it unpacks requirements from your casual English. Then it generates technical designs with data flows and API specs. Finally, it creates implementation tasks with testing requirements. Each step maintains clear links between what you wanted and what gets built.

Kiro also introduces "hooks"—automated tasks that trigger when you save files. Update a function and the tests update automatically. Change an API and the documentation refreshes. It's like having a very fast, very pedantic coworker who never sleeps.

The GeneXus Curveball

Here's where things get interesting. A company called GeneXus read Grove's talk and basically said "we've been doing this since 1988." They've spent 35 years building software that generates applications from high-level models. No AI required.

Their approach uses deterministic generators instead of large language models. Feed in a business specification and out comes working code for multiple platforms. The advantage? No hallucinations, no randomness, no need for human review. The downside? You need to learn their specific modeling language.

GeneXus makes a compelling point about reliability. When you're building mission-critical systems, you want consistency. AI models can vary their output even with identical inputs. Deterministic generators produce the same result every time. For a banking system, that matters more than natural language interfaces.

OpenAI's Living Example

The best proof of Grove's vision isn't theoretical—it's OpenAI's Model Spec. This document defines how OpenAI's models should behave. It's written in English, but it runs like code. The specifications train the models, generate test cases, and evaluate responses.

The Model Spec shows what specifications-as-code looks like in practice. It has version control, change logs, and collaborative editing. Different teams—product, legal, safety, research—can all contribute to the same source of truth. The models then implement these specifications across millions of conversations.

When OpenAI needed to fix their models' sycophancy problem, they didn't retrain the model from scratch. They updated the specification. The change propagated automatically through the system. That's the power of treating specifications as the primary artifact.

The Industry Split

The software world is dividing into two camps. One camp believes in "vibe coding"—casual prompts that generate working applications fast. The other camp wants structured development with documentation, testing, and enterprise governance.

Kiro tries to bridge this gap. It preserves the intuitive feel of AI-assisted development while adding the rigor enterprises demand. You can start with a vibe and end up with a specification. Or start with requirements and generate multiple implementations.

The pricing reflects this positioning. Kiro offers a free tier with 50 interactions per month, then paid tiers for heavier use. It's cloud-agnostic, unlike AWS's other developer tools. The message is clear: this isn't just another feature of Amazon's cloud platform. It's a new way of building software.

The Memory Problem

Meanwhile, AI agents are getting smarter about remembering context. Tools like n8n and Zep let agents build knowledge graphs about users, projects, and conversations. An agent remembers you're building an online store in React, like TypeScript better than JavaScript, and work at a bank.

This memory layer makes specifications more powerful. Agents don't start over each time. They remember past chats and learn your habits. They spot problems early and write specs the way your team does.

The cost optimization is crucial too. Naive implementations send every past conversation to the AI model, burning through tokens fast. Smart implementations search for relevant context and only include what matters. It's the difference between a chatbot that forgets everything and an AI pair programmer that learns how you work.

Why this matters:

• We're watching the biggest shift in software development since high-level programming languages—specifications are becoming the new source code, with traditional coding relegated to implementation details.

• The companies that master specification-driven development will build software faster, with better documentation, and fewer bugs—while their competitors are still arguing about code reviews and technical debt.

❓ Frequently Asked Questions

Q: How does Kiro actually turn a prompt into working code?

A: Kiro works in three phases: unpacking requirements from your prompt, generating technical designs with API specs, and creating implementation tasks with tests. It uses Claude Sonnet 4.0 and 3.7 models for processing, then creates "hooks" that automatically update tests and documentation when you change files.

Q: What is GeneXus and why does their 35-year claim matter?

A: GeneXus generates applications from business models using deterministic algorithms, not AI. They've done specification-driven development since 1988. Their approach produces identical results every time, unlike AI models that vary. For banking systems, this consistency beats natural language interfaces.

Q: How much does spec-driven development cost compared to traditional coding?

A: Kiro offers 50 free interactions monthly, then $19 for 1,000 interactions or $39 for 3,000. Traditional IDEs like VS Code are free, but you pay developers to write all code. The trade-off is AI interaction costs versus developer time for routine tasks.

Q: What's the difference between "vibe coding" and "spec coding"?

A: Vibe coding uses casual prompts to generate working apps quickly but lacks structure. Spec coding transforms prompts into detailed technical specifications with documentation, testing requirements, and implementation plans. Same speed, but with enterprise-grade governance and documentation.

Q: What was OpenAI's sycophancy problem with their models?

A: OpenAI's models were being overly agreeable and flattering users instead of giving truthful responses. They fixed this by updating their Model Spec document, which automatically changed behavior across all conversations. This shows specifications working as executable code rather than retraining models.

Q: What programming languages does this approach support?

A: Kiro is built on Code OSS (VS Code's base) and supports multiple platforms. The approach works with any language since it generates specifications first, then translates them to specific technologies like React, Python, or mobile apps.

Q: Can developers still write code the traditional way?

A: Yes. These tools don't replace traditional coding—they add a specification layer on top. Developers can still write code directly, but specifications provide structure, documentation, and automated testing. Think enhanced development, not replacement.

Q: How long before this becomes mainstream?

A: The tools exist now, but adoption depends on enterprise comfort with AI-generated code. AWS launching Kiro signals big companies are ready. Grove estimates 80% of development work is communication that AI handles poorly—solving that could accelerate adoption quickly.