← Back to Blog

Speed Changed, Understanding Didn't

Speed Changed, Understanding Didn't

Speed Changed, Understanding Didn't

Software development has changed drastically in some aspects but not in others. Development speed is the one that has changed the most, at least for certain kinds of work: with coding assistants, more can be done with fewer people and in a fraction of the time. Something that used to take a team a full sprint can now be prototyped by one person in an afternoon.

The speedup is real, but it is not universal. In a randomized study by METR, experienced developers working on large codebases they knew well were actually 19% slower with AI tools, while believing they were about 20% faster. Google's 2025 DORA report is more positive and links AI adoption to higher delivery throughput, but only teams with loosely coupled systems and fast feedback loops see the gains. In my experience the speed shows up most on new projects, prototypes and smaller systems, which is exactly where I use it.

Requirements are still the hard part

The part that has not changed is the need to really understand the requirements of the system being built, in the short and the long term. That has always been the real challenge in software development, and writing code faster does not solve it.

This is not a new idea. Fred Brooks argued back in 1986, in "No Silver Bullet", that tools can remove the accidental complexity of software but not the essential complexity of figuring out what to build. AI agents are a very powerful tool for the accidental part. The industry is arriving at the same conclusion: spec-driven development, with GitHub's Spec Kit, AWS's Kiro and others, treats the specification as the thing that decides whether AI speeds up delivery or just speeds up rework. Even Andrej Karpathy, who coined "vibe coding", now talks about agentic engineering: agents working against detailed specs, with humans in the loop.

The good thing is that now we can iterate quickly. But some changes are still expensive to fix, even with AI agents, once real production data is involved and real users depend on it. An agent can rewrite a screen in seconds; it can't undo a bad data model that already has a year of records and a few integrations built on top of it. Renaming a field, splitting a table or turning a one-to-many into a many-to-many means migrations, backfills and coordinating with everything that reads that data.

Can't the agent gather the requirements too?

To be fair to the other side of my own argument: yes, partly. Give an agent the emails, chats, meeting notes and tickets around a project, and in minutes it can draft user stories, a glossary and even a first data model. It can also spot contradictions ("in March they said invoices are monthly, in June they talk about weekly"), list open questions and suggest edge cases nobody mentioned. Reading 300 emails was always slow and error prone for humans; that part is genuinely faster now.

Where it breaks down:

  • Documents record what people said, not what is true or needed. A lot of what matters is tacit: the workaround everyone does every day, the rule everyone "just knows". An agent can't extract what was never written down.
  • Agents resolve contradictions instead of flagging them. When two emails disagree, the agent tends to pick one and write it confidently into the spec. It doesn't know the second one came from the person who actually decides, or that the first was a brainstorm.
  • Requirements are decisions, not just facts. Choosing between fast and auditable, or deciding which feature waits, needs someone accountable. An agent can lay out the options; it can't own the trade-off.
  • History describes the past. Long-term requirements are about where the business is going, and that is rarely in anyone's inbox.
  • Expertise still matters. Research on LLM-assisted requirements elicitation found that people with domain knowledge got more out of the tools. The agent amplifies whoever is steering it.

So agents speed up requirements the same way they speed up code: the mechanical part gets faster and the bottleneck moves to validation. The workflow I like is to have the agent read everything and draft the requirements together with a list of conflicts and open questions, then resolve those with the people who actually decide, and only then turn the result into the spec or model the agents build against. Often the most valuable output is the list of questions, not the spec, because it shows you what you don't understand yet.

One practical note: feeding client emails and private chats to an agent raises privacy and permission questions. Make sure you are allowed to share that data before you do.

Iterate fast, but small

There has always been an urgency to release code and get user feedback. In some cases that is possible and doable; in others it is pretty expensive, for example in systems that handle payments, medical records or anything where a wrong answer has real consequences.

I believe that since we can move quicker today, we should iterate quickly with a limited number of test users and reiterate as much as needed, when possible. The cost of throwing away a version has dropped a lot, so the goal is to make the mistakes while the blast radius is small: a handful of users, test data and no promises about backwards compatibility yet.

Let the stakeholders prototype

Another approach is to have the stakeholders play around with AI agents and build prototypes until they think it fits their needs. Since they have the most context, this way they could capture a lot of the requirements, often things they would never think to write in a spec but that show up immediately when they click through something that works.

It does not cover everything, for sure. A prototype usually skips the boring parts: permissions, edge cases, data validation, what happens when two people edit the same thing. It also adds the risk of them thinking the system is done, or that they can just do it themselves. The prototype is a great requirements document; it is not the product.

Karpathy himself scoped vibe coding to throwaway weekend projects from day one; that part got lost as the term spread. And the gap between a demo and production is where most of the work is: many vibe-coded prototypes stall before deployment or need a full rewrite. That is fine, as long as everyone knows the prototype is there to discover requirements, not to be shipped.

Building is only half of the equation

Having said this, building has always been only half of the equation. Systems are like living beings; they need maintenance and changes as the requirements evolve. That is why documentation is vital, for humans and for AI agents.

An AI agent starting a new session knows nothing about why a decision was made. If that context only lives in someone's head or in an old chat, the agent will guess, and it will guess confidently. Clear documentation of the data model, its constraints and the reasoning behind them is what lets the next change, made by a person or an agent, respect the original intent.

But more documentation is not automatically better. A study from ETH Zurich on AGENTS.md and CLAUDE.md files found that these context files tended to reduce agents' success rates while raising inference cost by over 20%. Coverage of the paper adds that files written by the developers helped a little, auto-generated ones hurt, and general codebase overviews did not help agents find the right files at all. The lesson I take from it: what helps an agent is information that is precise, structured and not already obvious from the code. A prose overview of the system is easy to write and easy to ignore; a formal definition of the data model is neither.

What r/golang taught me

A while ago I posted in r/golang about this exact approach: make the database schema the source of truth and generate everything from it (model the schema, generate the proto, then generate the Go code and sqlc). The one gotcha I had found was that once you are in production, new fields always have to be added at the end so nothing breaks. I asked what else I was missing, and the replies made the idea stronger.

  • The real danger is renames and deletes. One commenter, who maintains his own schema-to-code tools, pointed out that with forward-only migrations you only break things when you rename or delete a field, often because of a typo or because your naming got better. That is the "expensive to fix once production data is involved" point from earlier, in its most concrete form. An agent can write the migration in seconds; deciding how to deprecate a column real users depend on is still a human decision.
  • Don't tie your API contract to your tables. Another reply raised the coupling concern: the DB schema and the public API should not always mirror each other. I agree. The way I handle it is a generated core and a hand-written edge: the generated layer covers the boring, predictable parts, and business logic and the public contract live in code the generator never touches. Regenerating after a model change never overwrites a decision a human (or an agent) made on purpose.
  • Documentation belongs next to the model. The same commenter's tooling has a linter that requires comments on every table and field. That is the documentation argument from above, enforced at the schema level, exactly where both humans and agents will look first.

Why I built nuzur

I built nuzur to develop my own systems with AI agents. It gives me the speed, but I also retain control over the model of the system, which is the core of the architecture. (I'm thinking of smaller systems here, not huge enterprise systems with many subsystems.)

Understanding the data structure is important to keep building in a clean and future-proof way. In nuzur the model is the source of truth: entities, fields, relationships and enums are defined first, and the code is generated from them. When I ask an agent to add a feature, it works against that model instead of inventing tables on the fly.

Thoughtworks' Birgitta Böckeler describes spec-driven development as a ladder of ambition: spec-first (the spec drives one task and may be thrown away), spec-anchored (the spec lives on next to the code) and spec-as-source (the spec is the main thing humans edit). nuzur sits close to that last step, but for the data layer only: the model is what I edit, and the code follows from it. I think that is the right level of ambition for most small systems, because the data model is the part that is hardest to change later.

The model is just as relevant for the AI agents themselves. It speeds up development because the agent doesn't need to rediscover the structure every session, and it adds guardrails when modifying the model or adding data to the database: changes go through a draft and a review step instead of landing directly in production.

It also closes the loop with requirements gathering. An agent can propose a data model from a pile of documents, and nuzur gives me a place to review and correct that model before it turns into code and production data.

Faster, not easier

AI made building faster, not easier to get right. The speed is real, and we should use it to iterate more, test more and throw away more. But the things that were hard before, understanding the problem, getting the data model right and keeping a system healthy over time, are still hard. If anything, the tools that help with those parts matter more now than they did before. Speed changed; understanding didn't.

Sources