From Prompt to Product: Spec-Driven Development with Agent Workflows

In the fast-moving world of software development, we are constantly looking for ways to optimize our processes and improve the quality of our work. At the moment, we are seeing two opposing approaches:

• "Vibe coding" is an intuitive and creative approach in which developers quickly get into the "flow" in order to achieve results quickly.
• "Spec-Driven Development" with agent workflows is a structured approach that delivers reproducible and scalable results through precise specifications and the use of agents.

With the emergence of powerful tools such as OpenCode, working with agents and subagents is becoming especially important. We wanted to find out whether software development can work completely without "writing code ourselves" and how far a consistent agent-based approach can take us. That is why we started an experiment and are sharing our learnings here.

At OTTO, numerous AI initiatives are currently underway. The AI Engineering Excellence (AIEE) team provides cross-team enablement along the entire Product Development Lifecycle (PDLC). To test the potential of agents in a real project environment, we set up a two-week experiment together with the AIEE team:

• Goal: Bring an internal frontend to MVP (Minimum Viable Product).
• Constraint: Do not use a single manually written line of code.
• Additional constraint: Consistently avoid vibe coding.

To run the experiment efficiently and with a clear focus, we defined clear roles and a structured process:

AIEE Team

• Took on the enabler role and provided the necessary know-how on agent skills.
• Supported the project by advising on architectural decisions and handled quality assurance tasks.

Our Team

• Was responsible for implementing the project and steering the agents.
• Created the required specifications and ensured that requirements were clearly defined and documented.

Daily syncs, intensive pairing sessions, and fast iteration cycles complemented the setup. These measures promoted continuous exchange within the team and enabled us to solve challenges together. The result was a high level of knowledge sharing and a steep learning curve for everyone involved.

Specification-driven development is a methodological approach in software development in which software is implemented on the basis of detailed and clearly formulated specifications. Requirements are documented in writing before implementation begins and serve as the binding foundation for all subsequent development steps - in the context described here, also for the use of agents.

The core idea:
Instead of generating code directly, specifications are created first and then used to generate the code in a deterministic and traceable way.

Figure 1: Our Agentic Engineering Workflow - from requirements to approval.

This workflow helped us move faster while also improving code quality. By refining stories thoroughly, critically questioning plans, and clearly documenting decisions from the start, we avoided time-consuming correction loops. A solid planning phase ensured that our implementation was focused and efficient from the outset.

• Story: We start with a precise user story (problem, acceptance criteria, context).
• Plan: In planning mode with agents, we refine the story into an actionable roadmap, identify risks, and document decisions.
• Implement: In line with the reviewed plan, we write only small, verifiable code sections and commit at short checkpoints.
• Review: Finally, we check whether the code and the plan match and whether the plan was sufficient.

This "Story -> Plan -> Implement -> Review" cycle creates transparency, high quality, and fast iterations.

One of our most important learnings: A precise story (problem, acceptance criteria, boundaries) forms the foundation. A carefully reviewed plan builds on it and is challenged before the work begins.

Pitfall: Without this process, agents quickly get lost in unclear changes. In our experiment, we had not defined all return services, so not all of them were listed in the dropdown menu.

Solution strategy: Recording all artifacts (stories, plans, decisions) and consistently working according to the Story-Plan-Commit-Review cycle ensure transparency, quality, and speed.

The quality of the specification largely determines the quality of the result: unclear requirements lead to unclear results, while precise specifications lead to remarkably good outputs.

Pitfall: There is often a tendency to use agents as universal problem solvers and assign them many different tasks at the same time. The problem: the context window fills up, causing quality to drop significantly (from about 70% utilization).

Solution strategy: 

• Use subagents specifically where tasks are independent of one another and can be worked on in parallel.
• Clear responsibilities for each subagent keep the overview intact and ensure the quality of the results.

Here is an example prompt for implementation via subagents:
“Implement. Go task by task. Spawn a subagent for each task. Use TDD Red-Green-Refactor. Create a commit. Ask me questions if anything is not clear enough”

Our learning: tests from the start are essential. They catch errors early and provide confidence with every change. Without automated tests, undetected bugs crept in - for example, buttons that did not work or missing validations.

Pitfall: Agents generate code, but without tests there is no feedback channel for quality assurance, and regressions creep in.

Solution strategy: Require every subagent to create a test stub (unit or snapshot test) before implementation. With the "Red - Green - Refactor" process, we ensure that every change is verified before it moves into the main branch.

• By validating functionality early, potential bugs can be identified and fixed during the development process.
• Automated tests help prevent regressions by ensuring that new changes do not affect existing functionality.
• Iterations become safer and more controlled because continuous tests enable stable further development.