From Vibe Coding to Spec-Pushed Growth

I in my earlier article, “From Code to Insights: Software program Engineering Greatest Practices for Knowledge Analysts”, that engineering abilities and finest practices could be extremely helpful for analysts and different information professionals.

That is much more true now within the AI period, when we’ve got much more alternatives to construct our personal analytical instruments: from fancy information viewers that show charts or showcase totally different situations, to simulators that may predict outcomes primarily based on enter parameters. Personally, I take advantage of net purposes on a regular basis in my day-to-day work.

There was numerous hype round vibe coding, however it appears that evidently skilled engineers are already transferring past it and leaning extra towards spec-driven growth. Even Andrej Karpathy, who coined the time period “vibe coding” in February 2025, admitted only a 12 months later that this period is ending and that we’re getting into the age of agentic engineering — orchestrating brokers towards detailed specs with human oversight.

Right now (1 12 months later), programming by way of LLM brokers is more and more turning into a default workflow for professionals, besides with extra oversight and scrutiny. The objective is to assert the leverage from the usage of brokers however with none compromise on the standard of the software program. Many individuals have tried to provide you with a greater title for this to distinguish it from vibe coding, personally my present favourite “agentic engineering”: 
– “agentic” as a result of the brand new default is that you’re not writing the code instantly 99% of the time, you’re orchestrating brokers who do and performing as oversight. 
–  “engineering” to emphasise that there’s an artwork & science and experience to it. It’s one thing you’ll be able to study and grow to be higher at, with its personal depth of a unique type.

On this article, I’d wish to put spec-driven growth into follow on a greenfield mission, following the very best practices from JetBrains’ course on DeepLearning.AI, “Spec-Driven Development with Coding Agents”. 

The mission is a little more private, however nonetheless data-related. As I’m getting ready for my half marathon in September, I’m attempting to steadiness operating and energy coaching. There are such a lot of instruments on the market, every targeted on a unique a part of the journey, that discovering one resolution that actually works for me has been surprisingly tough. So, I made a decision to feed two birds with one scone: construct my very own net app whereas hopefully studying one thing new alongside the best way.

Prepared for motion? Me too. However earlier than we leap into implementation, let me first spend a couple of minutes on the speculation behind spec-driven growth.

Vibe coding vs Spec-driven growth

Many people have already skilled vibe coding: you write a brief immediate (for instance, “Please add a DAU chart to my net software”), watch for the agent to generate the change, run it regionally, and test whether or not the outcome matches your expectations.

Often, it doesn’t. So that you return to the identical chat, ask the agent to regulate the chart, and hold iterating till the result’s adequate.

This strategy works moderately properly for easy tasks, nevertheless it doesn’t scale properly, particularly when a number of builders are engaged on the identical codebase.

The primary drawbacks are the shortage of finest practices and shared conventions. For instance, with no structured strategy, groups can simply find yourself with 5 alternative ways to run ML mannequin coaching inside the identical DBT pipeline.

One other widespread problem is that we normally don’t persist the outcomes or reasoning from our conversations with AI brokers. In consequence, it turns into simple to lose observe of why sure choices have been made. For instance, an agent would possibly overlook why you cleaned up information in a selected method, and the following replace may silently introduce a unique outcome.

Context decay can be an particularly widespread drawback. AI brokers are stateless, and when engaged on bigger tasks, we frequently have to start out new chats due to context window limitations, successfully beginning our communication from scratch.

Spec-driven growth (SDD) is far nearer to conventional engineering practices. As a substitute of leaping straight into implementation, we begin by doing the arduous considering ourselves: making architectural choices, defining necessities, and documenting them in a structured markdown specification saved within the repository and up to date alongside the mission. This creates an essential shift: we decouple the specification (what we’re constructing and why) from the implementation (the precise code).

SDD addresses lots of the core problems with vibe coding by preserving context throughout periods (and even throughout totally different AI brokers) whereas aligning each people and brokers across the mission’s fundamental non-negotiables.

SDD workflow 

A typical spec-driven growth workflow normally consists of the next phases.

Step one is defining the structure — an settlement on the important thing choices for the mission. It normally consists of a number of core paperwork:

• Mission explains the why: why are we constructing this mission, and what are its key objectives and options?
• Tech Stack paperwork technical choices, in addition to deployment and replace processes.
• Roadmap outlines mission phases, deliberate options, and is repeatedly up to date because the mission evolves.

Specs could be created for each new and present tasks, which makes this strategy fairly versatile.

As soon as the project-level documentation is in place, we are able to transfer on to the function growth section, which usually consists of:

1. Understanding what we need to construct and writing an in depth specification.
2. Implementing the modifications.
3. Validating that the implementation works as anticipated.

After efficiently implementing your first function, you would possibly instantly really feel the urge to maneuver on to the following one. However that is truly the appropriate second to pause and rethink.

That is the place replanning is available in. It’s a devoted section for revisiting the structure and reviewing earlier function choices and plans to ensure they nonetheless align with the mission objectives.

Now that we’ve coated the speculation, let’s put it into follow.

Constructing 

Sufficient concept, it’s time to construct. To raised perceive how spec-driven growth works in follow, I made a decision to use it to an actual greenfield mission.

I began by creating a brand new repository for this mission (and, in fact, spending half an hour selecting the title and emblem): repository. I additionally documented my preliminary product imaginative and prescient within the README.md file.

One of many good issues concerning the SDD strategy is that it’s largely agnostic to the selection of LLM, agent, or IDE, so you’ll be able to work with no matter setup you like. For this mission, I’ll be utilizing Visible Studio Code with the Claude Code plugin, because it permits me to make use of Claude as an agent whereas additionally reviewing all code modifications instantly within the editor.

Making a structure

As we mentioned, step one is to write down the structure. In fact, we don’t must do it manually, we are able to use LLMs to place it collectively primarily based on the preliminary product imaginative and prescient, in addition to further context gathered by means of follow-up questions.

We're constructing Trainlytics, a private health monitoring net app constructed
for individuals who need extra management, flexibility, and insights than normal
health apps present. Discover the total necessities in README.md.

Let's create a "structure" in a specs listing that consists of 
the next components:
- mission.md - what and why we're constructing; the primary mission of the product
- tech-stack.md - core technical choices
- roadmap.md - mission phases damaged down in implementation order

IMPORTANT: It's essential to use your AskUserQuestion instrument to get my suggestions.

The agent then asks a collection of clarifying questions that assist outline the mission structure and create an preliminary implementation plan.

Ultimately, the agent created the three recordsdata we requested for.

At this level, you would possibly really feel the urge to right away ask the agent to start out constructing the mission, however that may be too quickly.

Earlier than transferring ahead, we first must validate and refine the structure. It’s price spending time now aligning on the plan, as a result of this specification will later translate into hundreds of strains of code. It’s a lot better to resolve ambiguities and errors early.

I normally do that by studying the paperwork myself and iterating with the agent, asking clarifying questions and refining the plan step-by-step. A very good follow is to make all modifications by means of the agent fairly than patching paperwork your self to keep up consistency throughout the mission. For instance, I advised the agent that we’d like authentication within the app, since my use case is to log exercises from each desktop and cell units. This led to updates in each the tech stack doc and the roadmap.

When you’re pleased with the assessment, you can even ask a second agent — with recent context — to critique the plan. There are many proof that reflection improves output high quality.

When all checks are full, it’s time to commit the structure to the repository.

First function section

Now, it’s time to maneuver on the primary function section. 
In line with our roadmap, we’ll begin with the MVP: Core Exercise Logging. On the finish of this section, a consumer ought to be capable to log in on each desktop and cell, report a run and a health club session, and look at each of their historical past with full particulars.

As mentioned, every function section follows a easy cycle: plan → implement → validate. So let’s begin by defining the specification and constructing the plan.

Discover the following section in specs/roadmap.md and create a brand new department, 
ask me about any steps within the specs that aren't absolutely clear.

Then create a brand new listing within the format YYYY-MM-DD-feature-name below specs/ 
for this function, with the next recordsdata:
- plan.md - a structured record of numbered process teams
- necessities.md - scope, key choices, and context
- validation.md - how we outline success and make sure the implementation can 
be merged

Use specs/mission.md and specs/tech-stack.md as steering.

Tip: it’s price beginning a brand new session with clear context in your LLM agent.

The agent put collectively specs fairly shortly. 

At this level, it’s once more time to assessment the specs and guarantee every little thing is aligned with the unique imaginative and prescient. As you’ll be able to see, with agentic engineering, the position of the developer shifts towards steering, reviewing, and making architectural choices, fairly than instantly writing specs or code.

When you’re pleased with the plan, it’s time to maneuver on to implementation. I choose to implement every group of duties individually fairly than one-shotting the whole function section, however this relies on the dimensions of the function. For this mission, I used the next immediate.

Take the following process group from 2026-05-04-phase-1-mvp/plan.md and implement it.
Use necessities.md and validation.md for steering.
As soon as performed, replace the standing in each the plan and validation paperwork.

When the code is prepared, it’s time for assessment. This is among the most essential steps, so it’s price investing a while right here.

In data-related purposes, I normally focus my assessment on the core enterprise logic and test that the numbers match my expectations.

I need to confess that I’ve near zero information of frontend applied sciences, so I not often assessment frontend code intimately. As a substitute, I merely take a look at the interface regionally and test whether or not every little thing works as anticipated. For this case, I made a decision to run the app and see the way it works.

After a number of iterations with the agent, we managed to run the app regionally, and it labored. We are able to already add totally different workouts and exercise varieties, and log each cardio and energy periods.

After the handbook assessment, it’s additionally helpful to make use of reflection and ask the brand new agent to confirm whether or not the implementation aligns with the plan, in addition to to undergo the factors outlined in validation.md. 

In concept, spec-driven growth means that the function section ends with validation. In follow, it not often works that cleanly. You’ll doubtless discover that some components of the implementation don’t work as anticipated. At that time, you’ve got two choices:

• Add a pair extra iterations to your plan.md and proceed refining the function (this works properly for smaller modifications), or
• If the problems are extra substantial, deal with them as a part of the following function section and deal with them throughout replanning.

One essential factor to be careful for: it may be tempting to easily clarify the problem to the LLM agent and ask for fixes, as a substitute of updating the specs and transforming the implementation. Attempt to withstand that shortcut. Protecting the specification because the supply of reality is what makes the strategy sturdy.

As soon as all checks are full, we are able to create and merge the pull request.

At this level, we have already got a working software and the outcomes are genuinely satisfying. Much more surprisingly, the entire course of took only a bit greater than two hours end-to-end (together with drafting this text whereas the agent was working).

Replanning

With such good progress, you would possibly really feel the urge to proceed constructing. I perceive that, however within the present AI period, the primary worth of a human lies in considering and structure. So that is truly the appropriate second to step again and mirror: can we nonetheless need to proceed in the identical course, and what ought to we alter in our product and course of?

Once I began utilizing the applying myself, I realised it wasn’t but prepared to completely assist my use case. Which means we have to reprioritise so I can begin utilizing it in my day-to-day life as quickly as potential. So, I did it with the next immediate.

Let's revise our plan in roadmap.md.
I'd prioritise the following phases as follows:
1. Power session templates
I can stay with out planning, however I would like templates, as a result of I usually battle 
to recollect all of the workouts in a session.

The thought is:
- If a template already exists within the log, present all stats (workouts, units, 
reps, weight, and many others.). Permit modifying these values and committing modifications
- If something is modified, ask whether or not the consumer needs to replace the template

2. UI enhancements
The present design just isn't but modern sufficient, so I might prioritise a spherical of UI 
enhancements:
- Add the emblem and product motto to the web site
- Add a settings tab to handle exercise varieties and workouts
- Create a single display screen to log each cardio and energy periods
- Enhance the historical past display screen with richer exercise particulars
- Permit including titles to actions (energy/cardio periods) and segments
- Assist specifying time, not solely date
- Add extra coloration to the interface (I like shades of blue)
- For cardio workouts, regulate items to: minutes, kilometers, and min/km tempo

3. Fundamental analytics
Add easy analytics to the historical past display screen displaying weekly stats at
the highest of the web page (e.g. whole minutes and energy cut up between cardio
and energy).

Replanning can be second to revisit our course of itself. For instance, I seen that we haven’t up to date roadmap.md persistently, and the specs are beginning to drift. It could even be helpful to introduce a changelog, so we’ve got a transparent historical past of how the product has developed over time. 

Let’s ask agent to do it for us.

Please assessment plan.md, replace roadmap.md to mirror accomplished work, 
and create a CHANGELOG.md file with a concise abstract of the modifications.

Now that we’re aligned on course and have the appropriate setup in place, let’s hold constructing.

The following section

Now we are able to observe the identical course of and iterate by means of phases. Since it is a repeatable cycle, it’s second to debate potential automations.

Up to now, we’ve been writing all prompts manually, however these workflows will also be automated as “abilities” in Claude Code or different LLM coding brokers.

Additionally, there are already implementations of spec-driven growth that can be utilized out of the field. One of the crucial standard is Spec Kit by GitHub.

You’ll be able to set up it like this.

uv instrument set up specify-cli --from git+https://github.com/github/spec-kit.git
specify model # to test that it really works

Subsequent, you might want to initialise the abilities in Claude. This units up the .specify/ folder and installs slash instructions into .claude/instructions/

specify init . --integration claude 
# there are 30 integrations with brokers so specify the one you are utilizing

You’ll comprehend it labored when see the speckit instructions within the Claude Code.

As soon as put in, you’ll be able to observe an identical workflow: begin by defining the structure, then iterate by means of function loops.

One distinction is that in Spec Equipment, the structure is extra targeted on high-level considerations like code high quality, testing requirements, UX consistency, and efficiency necessities.

To be sincere, I barely choose the strategy proposed by JetBrains, as a result of it retains extra context within the structure itself. However as all the time, there isn’t any silver bullet and Spec Equipment may go higher relying in your use case. It’s additionally handy that you’ve SDD workflow already carried out for you.

Utilizing Spec Equipment, I ran by means of the 2 phases described above, and it labored properly. After the primary function section, growth naturally turns into a steady enchancment cycle fairly than a linear course of. And with that, I believe it’s time to wrap up this story.

Abstract 

In whole, it took me round 4.5 hours to construct a usable end-to-end product for monitoring and analysing my information. There may be nonetheless loads of room for enchancment, and I’ll proceed iterating on it. I can already see a number of potential UI enhancements, and I’d additionally wish to finally combine AI to make the app extra clever.

Frankly talking, it has been an attention-grabbing expertise working by means of such a structured growth movement. In my day-to-day work, I usually depend on one-off LLM chats to make modifications, with out sustaining a full hint of selections and specs within the repository.

Nevertheless, there isn’t any one-size-fits-all strategy right here.

• In case you simply need to make a small enchancment or run some ad-hoc evaluation in one more Jupyter pocket book, writing full specs upfront might be overkill.
• However if you’re engaged on a bigger mission (particularly with different individuals) spec-driven growth would undoubtedly be my default strategy.

It’s additionally attention-grabbing to watch how the position of an engineer is shifting: from writing code on to focusing extra on architectural choices, assessment, and system design.

And whereas it might sound a bit excessive at this time, I do suppose we’re regularly transferring towards a world the place English turns into the first “programming language” interface. We’re already seeing early makes an attempt on this course, similar to CodeSpeak, which discover extra natural-language-driven programming paradigms. I’ll strive CodeSpeak in my subsequent article, so keep tuned.

Reference

This text is impressed by the “Spec-Driven Development with Coding Agents” quick course from DeepLearning.AI.