From Vibe Coding to Spec-Pushed Growth

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

That is much more true now within the AI period, when we have now way more alternatives to construct our personal analytical instruments: from fancy knowledge viewers that show charts or showcase totally different eventualities, to simulators that may predict outcomes based mostly on enter parameters. Personally, I exploit internet purposes on a regular basis in my day-to-day work.

There was quite a lot of hype round vibe coding, however 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 in opposition to detailed specs with human oversight.

Right this moment (1 12 months later), programming through LLM brokers is more and more turning into a default workflow for professionals, besides with extra oversight and scrutiny. The aim 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 identify 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 immediately 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 may be taught and grow to be higher at, with its personal depth of a distinct type.

On this article, I’d prefer to put spec-driven growth into follow on a greenfield undertaking, following the most effective practices from JetBrains’ course on DeepLearning.AI, “Spec-Pushed Growth with Coding Brokers”. 

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

Prepared for motion? Me too. However earlier than we bounce into implementation, let me first spend a couple of minutes on the idea 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 internet utility”), anticipate the agent to generate the change, run it regionally, and verify whether or not the end result matches your expectations.

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

This strategy works fairly effectively for easy tasks, but it surely doesn’t scale effectively, particularly when a number of builders are engaged on the identical codebase.

The principle drawbacks are the shortage of finest practices and shared conventions. For instance, and not using a structured strategy, groups can simply find yourself with 5 other 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 straightforward to lose observe of why sure selections have been made. For instance, an agent would possibly neglect why you cleaned up knowledge in a specific approach, and the subsequent replace may silently introduce a distinct end result.

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

Spec-driven growth (SDD) is way nearer to conventional engineering practices. As a substitute of leaping straight into implementation, we begin by doing the laborious pondering ourselves: making architectural selections, defining necessities, and documenting them in a structured markdown specification saved within the repository and up to date alongside the undertaking. This creates an vital 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 undertaking’s essential 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 selections for the undertaking. It normally contains a number of core paperwork:

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

Specs may 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 contains:

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 subsequent one. However that is really the proper 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 selections and plans to verify they nonetheless align with the undertaking objectives.

Now that we’ve coated the idea, 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 undertaking.

I began by creating a brand new repository for this undertaking (and, in fact, spending half an hour selecting the identify and brand): 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 may work with no matter setup you favor. For this undertaking, 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 immediately within the editor.

Making a structure

As we mentioned, step one is to put in writing the structure. After all, we don’t have to do it manually, we are able to use LLMs to place it collectively based mostly on the preliminary product imaginative and prescient, in addition to extra context gathered by means of follow-up questions.

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

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

IMPORTANT: You could use your AskUserQuestion instrument to get my suggestions.

The agent then asks a collection of clarifying questions that assist outline the undertaking 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 instantly ask the agent to start out constructing the undertaking, however that may be too quickly.

Earlier than transferring ahead, we first have to 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 1000’s of strains of code. It’s significantly 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. follow is to make all modifications by means of the agent quite than patching paperwork your self to take care of consistency throughout the undertaking. For instance, I instructed 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 proud of the evaluate, you too can ask a second agent — with recent context — to critique the plan. There are plenty of 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. 
Based on our roadmap, we’ll begin with the MVP: Core Exercise Logging. On the finish of this section, a person ought to have the ability to log in on each desktop and cell, document a run and a gymnasium 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 subsequent 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 underneath specs/ 
for this function, with the next recordsdata:
- plan.md - a structured listing of numbered process teams
- necessities.md - scope, key selections, and context
- validation.md - how we outline success and ensure the implementation can 
be merged

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

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

The agent put collectively specs fairly rapidly. 

At this level, it’s once more time to evaluate the specs and guarantee every little thing is aligned with the unique imaginative and prescient. As you may see, with agentic engineering, the function of the developer shifts towards steering, reviewing, and making architectural selections, quite than immediately writing specs or code.

When you’re proud of the plan, it’s time to maneuver on to implementation. I choose to implement every group of duties individually quite than one-shotting the whole function section, however this is determined by the scale of the function. For this undertaking, I used the next immediate.

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

When the code is prepared, it’s time for evaluate. This is without doubt one of the most vital steps, so it’s price investing a while right here.

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

I have to confess that I’ve near zero information of frontend applied sciences, so I hardly ever evaluate frontend code intimately. As a substitute, I merely take a look at the interface regionally and verify 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 sorts, and log each cardio and energy periods.

After the guide evaluate, 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 hardly ever works that cleanly. You’ll possible discover that some elements of the implementation don’t work as anticipated. At that time, you could have two choices:

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

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

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 utility 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 pondering and structure. So that is really the proper second to step again and mirror: can we nonetheless need to proceed in the identical path, and what ought to we modify in our product and course of?

After I began utilizing the appliance myself, I realised it wasn’t but prepared to completely help my use case. Meaning 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 subsequent phases as follows:
1. Power session templates
I can reside with out planning, however I would like templates, as a result of I typically wrestle 
to recollect all of the workouts in a session.

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

2. UI enhancements
The present design shouldn't be but glossy 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 sorts 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
- Help specifying time, not solely date
- Add extra coloration to the interface (I like shades of blue)
- For cardio workouts, regulate models to: minutes, kilometers, and min/km tempo

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

Replanning can also be an excellent second to revisit our course of itself. For instance, I seen that we haven’t up to date roadmap.md constantly, and the specs are beginning to drift. It might even be helpful to introduce a changelog, so we have now a transparent historical past of how the product has advanced over time. 

Let’s ask agent to do it for us.

Please evaluate 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 path and have the proper setup in place, let’s preserve constructing.

The following section

Now we are able to comply with the identical course of and iterate by means of phases. Since this can be a repeatable cycle, it’s an excellent second to debate potential automations.

To date, we’ve been writing all prompts manually, however these workflows can be automated as “expertise” 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 widespread is Spec Package by GitHub.

You may set up it like this.

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

Subsequent, you might want to initialise the talents 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 understand it labored when see the speckit instructions within the Claude Code.

As soon as put in, you may comply with an identical workflow: begin by defining the structure, then iterate by means of function loops.

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

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

Utilizing Spec Package, I ran by means of the 2 phases described above, and it labored effectively. After the primary function section, growth naturally turns into a steady enchancment cycle quite than a linear course of. And with that, I feel 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 knowledge. 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 prefer to finally combine AI to make the app extra clever.

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

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

• For those who 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 once you’re engaged on a bigger undertaking (particularly with different folks) spec-driven growth would undoubtedly be my default strategy.

It’s additionally fascinating to look at how the function of an engineer is shifting: from writing code on to focusing extra on architectural selections, evaluate, and system design.

And whereas it could sound a bit excessive immediately, I do suppose we’re steadily transferring towards a world the place English turns into the first “programming language” interface. We’re already seeing early makes an attempt on this path, reminiscent of CodeSpeak, which discover extra natural-language-driven programming paradigms. I’ll attempt CodeSpeak in my subsequent article, so keep tuned.

Reference

This text is impressed by the “Spec-Pushed Growth with Coding Brokers” brief course from DeepLearning.AI.