Spec-Driven Development: How AI Coding Moves Beyond Vibe Coding

Vibe Coding isn't "vibe" anymore. It looks more like an engineering approach to solving problems if you use spec-driven development. I tried to use this approach in my new project AgentD (an infrastructure to run AI Agents on the local machine in the same way Docker runs containers). And in this article I will explain what "spec-driven development" is.

Vibe Coding Session

Before speaking about a new approach, let's see the "old" vibe coding sessions:

Loading...

1. Developer asks Codex / Claude Code to develop some application.
2. Codex edits code and provides a response to the developer.
3. Developer controls Codex execution and asks for more changes.

As a result, Developer should sit with his laptop and constantly chat with Codex or Claude Code to build some application. This is very similar to how Developer developed an application in the old days by writing code manually, but code writing is sped up with Codex.

Pros:

• Speed up of software development.
• It's super cheap for Developer to check new theories or implement new features.

Cons:

• Full involvement in the development process by Developer without the possibility to parallelize work.
• Micromanagement of AI which doesn't allow Developer to think more about the purpose of the project and problem solving. Developer is still involved in the very low-level way of writing code.

The spec-driven development solves the cons mentioned above and improves Developer performance even more. Let's see how it is different.

Spec-Driven Development Session

Spec - this is the technical document with all functional and non-functional requirements for the software. AI will follow these requirements during the implementation process.

The session starts from the spec document writing with the AI:

Loading...

1. Developer explains what app he wants to build.
2. Codex creates a spec file, which is just a Markdown file.
3. Developer reviews the created spec and updates it if needed.

After that the plan stage starts:

Loading...

1. Developer asks to generate a plan from the spec.
2. Codex generates a plan document which is still a Markdown file, but splits technical requirements into the planned implementation.
3. Developer reviews and updates the plan if needed.

After that, the plan needs to be split into tasks:

Loading...

1. Developer asks Codex to split the plan into tasks.
2. Codex creates the task document, which is a Markdown file from the plan.
3. Developer reviews and updates the tasks document.

And only right now Codex will be allowed to write actual code:

Loading...

1. Developer asks Codex to implement tasks.
2. Codex implements all tasks by editing source code.

The task implementation process may take 1 hour or even more. This depends on the complexity of the spec and the amount of tasks. But due to the detailed spec, AI will cover all specified edge cases, and the quality of the produced software fully depends on the quality of the spec. This approach is much better than the "vibe coding" option.

Pros

• AI fully follows defined requirements for the software which should be developed.
• From day 1 the software has comprehensive documentation which allows you to easily rewrite and support it with AI.
• After the preparation stage, Developer can focus on other tasks by leaving AI to implement the spec document for some time.
• Performance of Developer is improved in comparison to the "vibe coding" option.

Cons

• The preparation stage requires more time from the Developer to think about what software he wants to produce with AI. This requires the Developer to have skills which previously Product Manager or Lead Engineer had. That's why Developer should better understand the product he wants to build.
• Developer should review spec, plan and tasks documents very carefully to be sure that the correct software will be produced by AI.

Let's see the real-world project which I built with this spec-driven development approach.

GitHub Spec Kit

There are many skills for AI Agents to enable spec-driven development, but I used the GitHub Spec Kit. It makes it very easy to start a new project with this approach by simply running one bash command:

1specify init <project_name>

After this, all required skills, scripts and plugins will be installed for the specified AI Agent platform. For a more detailed guide see the repository or check this YouTube tutorial: The ONLY guide you'll need for GitHub Spec Kit.

AgentD

To test the spec-driven development flow I decided to build an infrastructure project which will schedule AI Agents and run them in the same way as Docker runs containers.

My core requirements were:

• Schedule and run custom AI Agents.
• AI Agents should be able to be defined in a plain Markdown file.
• An infrastructure should be lightweight like Docker and should run as a system service.
• Have Docker-like CLI access to AI Agents.

AgentD repository: https://github.com/vitalii-honchar/agentd. So I initialized specs and ran initial development. On the day of writing this article I have 4 specs: Loading...

These specs were fully implemented by Codex. I didn't touch any Go code lines. And the development was really long. Some specs were implemented for more than 1 hour, but some took less time:

Loading...

And at the end of the project development I had working code which would need much more time to write manually rather than ~5 hours of Codex work. It was really scary for me. Because my first impression was that for the regular Senior Software Engineer it would take a couple weeks to develop a similar infrastructure service. For Codex it took ~5 hours and the spec-driven development approach.

If I used vibe coding I think that it would be impossible to build something like this in 5 hours. Because vibe coding requires human attention, focus and it's very easy to dive into not so important things instead of going to the main target - solved business problem. While spec-driven development allows AI to focus solely on solving the business problem defined in the spec file.

Software Engineering Future

The AI race is wild and it's too early to make some conclusions about the Software Engineering future. But I as a software engineer take it very personally because I invested a lot of my time in this specialization and I honestly love software engineering. And AI capabilities are so strong that they scare me because right now I can develop an infrastructure service which would take me a couple of weeks to develop in 5 hours.

And this is not AI maximum. It's 2026, and one year ago when Claude Code was released we had the very beginning of the vibe coding era. Right now we have fully autonomous spec-driven systems which write code by the defined spec.

And what does it mean for the software engineer? Let's see facts:

• Software Engineer can build software much much faster with the spec-driven development workflow.
• Software development is becoming cheap (yes I know that Claude Code has low limits but common Chinese models are open source, they are slightly worse than Claude Code or Codex but much cheaper, so it's a question of time when it will be even cheaper and quality will be better)
• Software is produced with enormous speed.
• Not all businesses are adapting AI at the same speed as AI is evolving.
• Publicly available LLM models like ChatGPT or Opus don't allow you to run normal security audits or pentesting even for your own software in a fully controlled environment.

Just want to mention the second time: spec-driven development is what makes AI development really magic, not vibe coding. Vibe coding is yesterday.

So from facts I can say that software engineering is changing and I see a couple opportunities:

• Master new AI tools and approaches. It makes sense to understand what AI capabilities exist and be able to solve business problems more actively.
• Due to the very high speed of the software delivery and cybersecurity restrictions of LLMs, cybersecurity will be more in demand because hacking of the poorly designed software will be more popular. Also keep into account that LLMs are pretty restrictive for cybersecurity questions (try to ask your LLM how to hack your own software - an answer will be banned). That's why getting offensive skills for software engineers may be pretty valuable to run security audits for apps.
• As far as many companies are not adapting AI or adapting AI slowly, it gives an opportunity for skilled software engineers to provide consultancy services for such companies to adapt AI.

Personally, I think that I will keep up-to-date with new AI approaches in software engineering and will improve cybersecurity skills. I still believe that product development and companies will benefit from new AI tools, and engineers who can use them efficiently will be in demand.

But the biggest conclusion for me is that the role of the software engineer is moving higher. Writing code is becoming cheaper. Thinking clearly about the problem, defining requirements, finding edge cases, reviewing architecture, and validating the result are becoming more important. Spec-driven development makes this shift very visible because AI can write a lot of code, but it still needs a good direction.

That is why spec-driven development was so impactful for me. It made me think seriously about the future path for software engineers. I don't think the answer is to ignore AI or compete with it by typing code faster. The better answer is to learn how to use AI as an execution engine and become better at defining what should be built.

And if you haven't tried spec-driven development yet, try it. It's really worth your effort.