Here's a product requirement:
Users should be able to invite members into an organization, assign roles, and control access to individual projects.
Hand it to an AI agent and it can start writing code within seconds. Hand it to an experienced engineer and they start asking questions:
- How should the authorization model work?
- How do organization-level and project-level permissions interact?
- Should permissions be inherited?
- How does this fit into the existing identity architecture?
- What happens when a user belongs to multiple organizations?
- What changes are required across services, APIs, databases and frontend applications?
- What are the security and migration implications?
The requirement answers none of these. And none of them are about typing code. They're about understanding the existing system, exploring alternatives, challenging assumptions and making architectural decisions.
That is engineering. It's precisely where experienced developers bring the most value.
Meanwhile, AI coding assistants have evolved into autonomous agents. They explore codebases, implement features, generate tests, fix bugs, and even coordinate with other agents. The direction seems clear: less human involvement in implementation, more automation, and increasingly autonomous software production.
So where do those seven questions go?
Are we building a future that makes software engineering better, or simply one that makes software production more autonomous? These are not necessarily the same thing. Get it wrong, and we replace the experience of engineering with the experience of managing agents. I'll come back to that.
Where do the questions go today?#
There are three main ways we're bringing AI into development, and each gives a different answer.
AI-assisted development is where most developers started. AI helps write functions, explain code, generate tests, suggest fixes and automate repetitive work. The developer remains in control of almost everything, so the engineer still asks the seven questions and AI helps type the answers. The limitation is that AI gets treated as an advanced autocomplete rather than a collaborator in the broader engineering process.
Autonomous software factories take automation much further. Humans define requirements, and AI agents take responsibility for implementation, testing, reviewing, and potentially delivering the software. The objective is to minimize human intervention and maximize throughput. There is genuine value here, particularly for predictable, repetitive, well-defined tasks. But if the goal is to remove developers from implementation, what happens to the intellectual and creative side of engineering? The seven questions don't disappear. Unless someone explores and resolves them explicitly, they become assumptions baked into whatever the agent happens to build.
Spec-driven development is the most promising of the three, because it writes things down. Specifications become the central source of truth: developers write structured specs that guide agents through planning, implementation and verification. Agents need context, constraints and clear expectations, so this is a meaningful improvement.
But which spec?
A product spec is not an engineering spec#
Write our requirement up as a specification and you get a product spec: what users need and what the software should accomplish. It can describe the expected behavior perfectly.
It still won't explain how that functionality should fit into the existing architecture, how systems should interact, what data models are required, or which technical trade-offs to make. Those are the seven questions, and they live in the gap between product intent and implementation.
Generating tasks from a product spec doesn't make that gap go away. Neither do agents that write better code.
Closing the gap: three layers of specification#
Spec-driven development is right that agents need specifications. It just needs more than one. I'd distinguish three layers:
- Product specification: what and why. Business requirements, user journeys, expected behavior, acceptance criteria and product constraints.
- Engineering specification: how, and why technically. Architecture, data models, APIs, integrations, security, performance, system boundaries, dependencies and technical trade-offs.
- Implementation specification: what needs to change. Technical tasks, affected components, code changes, test strategies, dependencies and verification criteria.
AI can help significantly at all three levels, but each needs a different kind of reasoning and validation.
These don't need to be three separate documents. They're three distinct levels of understanding, which can evolve together and stay connected. And they aren't a one-way pipeline. Moving between them is where discovery happens, and discoveries flow backward. Engineering discoveries change product assumptions. Implementation experiments reveal architectural problems. New technical constraints force product decisions.
Software development is not a linear pipeline from requirements to code. It's a continuous process of discovery and refinement.
Humans belong between the layers#
If the thinking happens between the layers, that's where developers should be. Not removed from the process, and not doing everything by hand either.
This doesn't mean every decision needs human approval. Established patterns, well-understood constraints and predictable engineering tasks can be delegated. Human involvement should increase with uncertainty, architectural impact, and the consequences of getting a decision wrong.
The model I believe in is autonomous execution, augmented engineering. Automate the mechanical burden of development, and amplify the capabilities of the people doing the engineering. AI takes responsibility where automation provides clear value. Developers stay actively involved where human judgment, creativity and exploration matter.
| Engineering activity | The role AI should play |
|---|---|
| Boilerplate and repetitive code | Automate it |
| Documentation and routine tests | Automate much of it |
| Predictable implementation tasks | Delegate to autonomous agents |
| Exploring technical alternatives | Collaborate |
| Prototyping different approaches | Experiment together |
| Debugging complex systems | Investigate together |
| Understanding unfamiliar technologies | Act as a tutor and experiment partner |
| Architecture and design | Augment human judgment |
| Creative problem-solving | Keep humans actively involved |
The objective shouldn't be to minimize the developer's involvement. It should be to maximize the value, and the enjoyment, of that involvement.
Back to our requirement#
Here's how the invite-and-roles requirement could move through a team working this way.
Explore the problem
This is product and engineering discovery. Before anyone writes a detailed spec, the developer and AI explore the problem together: brainstorm ideas, challenge assumptions, investigate how organizations and access work in the system today, check what the existing architecture allows, and experiment with possible solutions. Not everything needs to be specified immediately. Sometimes discovering what should be built is more valuable than documenting what we initially thought we wanted.
Design it together
This is the engineering spec. AI investigates the existing identity architecture, identifies the services, APIs, databases and frontends the change touches, explores alternatives for the authorization model, and highlights security and migration risks. The developer makes the decisions: how permissions inherit, how organization and project roles interact. The outcome answers the seven questions and bridges product intent and implementation.
Let agents execute against the spec
This is the implementation spec. The engineering spec gets broken down into tasks, affected components, test strategy and verification criteria. Then autonomous agents can take over much of the work. They generate code, create tests, modify APIs, update documentation and work across multiple components. The specification provides direction and constraints, and automated verification checks that the result meets expectations.
Investigate failures together
Not everything will work as expected. When agents run into unexpected behavior, architectural conflicts or complex bugs, developers investigate alongside them. The goal isn't to blindly retry until something passes. It's to understand why something failed and decide on the right solution, even when that means going back a layer.
Keep learning
AI also helps developers understand what was implemented, why particular decisions were made, and which alternatives were considered. The developer comes out knowing the permission model better, not depending on an agent to explain it.
The seven questions got asked. A human answered them, with AI's help, and wrote the answers down where the agents could use them. That's the difference.
What we should actually measure#
We tend to measure the success of AI-powered development with numbers like lines of code generated, tasks completed, features delivered per sprint, agents running concurrently, or engineering hours saved.
Those are useful, but they don't tell the whole story. We should also ask:
- Are developers solving more interesting problems?
- Are they learning more while building?
- Are they spending more time exploring and experimenting?
- Are they developing a deeper understanding of their systems?
- Are they spending less time on frustrating, repetitive work?
- Are they still enjoying the process of creating software?
This is the risk I mentioned at the start. Developers might spend their days writing specifications, decomposing tasks, reviewing generated code, monitoring execution and coordinating agents. We might produce more software, but that doesn't automatically mean we've created a better engineering profession.
The difficult parts of software development aren't always the parts we should eliminate. Sometimes, they're precisely the parts that make engineering rewarding.
Automate the tedious, not the thinking#
I don't think autonomous agents are the enemy of developers. Neither is spec-driven development. Both are important steps forward. But we should be careful not to confuse the automation of software production with the evolution of software engineering.
Autonomous agents expand our execution capacity. Specifications provide structure and consistency. AI-assisted exploration expands our ability to reason, experiment and learn. The real opportunity is to combine these capabilities rather than optimize for just one of them.
Three principles I'd build on:
- Automate the tedious, not the thinking.
- Accelerate experimentation, not just implementation.
- Amplify human creativity, curiosity, and engineering judgment.
We should absolutely build autonomous software factories where they make sense. But we should also build development environments where engineers can explore ideas, experiment with architectures, solve difficult problems, and create things they couldn't have created before.
The ultimate measure of progress shouldn't simply be how little human involvement software requires. It should also be how much more capable, creative and fulfilled the people building that software become.
The future shouldn't be about engineering without engineers. It should be about engineers who can do more, understand more, explore more, and enjoy building software again.