Technology & Architecture

Beyond Vibe Coding: Using AI in Software Development Without Losing Control

AI can dramatically accelerate software development. But as execution gets faster, scope, guardrails, verification and human judgement become even more important.

From vibe coding to AI-assisted engineering: using AI to accelerate software development while preserving control, verification and human ownership

Over the past few months, I have used AI coding tools increasingly intensively while developing a real product.

Not to build a demo.

Not to see how much code they could generate.

But to work on a system that, in the meantime, was becoming progressively more complex: parsing, persistence, analytics, queries, APIs, frontend, performance, testing and refactoring.

At first, the promise seems simple:

describe what you want and let AI build it.

That is the appeal of vibe coding.

It works surprisingly well.

At least until the problem is no longer generating code.

The problem becomes maintaining control over the system that code is building.

That is where, for me, everything changes.

The interesting transition is not:

human coding → AI coding

It is:

AI-generated software → AI-assisted engineering

And the difference lies mainly in one word:

judgement.

From a generic prompt to a micro-specification: problem, scope, constraints, acceptance criteria and verification

Generating Code Is Not Engineering

With a coding agent, I can produce very quickly:

  • endpoints;
  • queries;
  • components;
  • tests;
  • migrations;
  • refactoring;
  • documentation.

This dramatically reduces the cost of execution.

But it does not automatically reduce the cost of decisions.

What problem are we really solving?

Which part of the system can be changed?

Which invariants must remain intact?

When is a solution good enough?

Which regression would be unacceptable?

When should we stop?

These questions existed before AI.

The difference is that today we can produce the wrong solution much faster.

The cheaper execution becomes, the more valuable judgement becomes.

The Problem with Overly Open-Ended Prompts

A request such as:

“optimise this query”

seems perfectly reasonable.

But it leaves many interpretations open.

AI might:

  • rewrite the query;
  • change the semantics;
  • introduce caching;
  • modify the API contract;
  • add dependencies;
  • change the data model;
  • alter code that was not part of the problem.

It might even produce something technically better.

And still violate what we wanted to achieve.

The problem is not necessarily the quality of the solution.

It is the absence of boundaries.

From Prompt to Micro-Specification

I therefore began to treat many requests to AI as small technical specifications.

Not:

“improve performance.”

But something closer to:

Problem

Reading statistics by position is slow.

Scope

Analyse the query, the SQLite query plan and the indexes involved.

Constraints

Do not change the analytical semantics.

Do not change the API contract.

Do not introduce new dependencies.

Acceptance criteria

The query must return the same results.

The build must pass.

The existing tests must remain green.

The query plan must show the expected improvement.

This form of request radically changes the relationship with the coding agent.

I am no longer asking it:

“find a solution.”

I am telling it:

“work within this decision space.”

Read First, Change Later

One of the rules that proved most useful was extremely simple:

read first, then change.

Before asking for a patch:

  • read the files involved;
  • reconstruct the flow;
  • identify dependencies;
  • check existing tests;
  • identify invariants;
  • explain the probable cause.

Only then:

propose a change.

It sounds like a slowdown.

In practice, it often accelerates the work.

It avoids patches built on a partial understanding of the system.

Above all, it reduces a typical risk of AI coding: correctly modifying the wrong file or elegantly solving the wrong problem.

“Done” Does Not Mean Verified

There is another fundamental distinction.

A coding agent can say:

“Implemented successfully.”

But that sentence is not evidence.

It is an assertion.

The evidence comes from the system.

AI’s claimed output is compared with the build, tests, linting, benchmark, query plan and unchanged results

While developing the parser, for example, verification did not mean asking the model whether the parser worked.

It meant running it against real data.

At one stage of the project, the verification corpus contained:

6 real files

404 hands

The result:

404 parsed

0 failures

On a file containing 117 hands, the observed time was in the region of:

~72 ms

approximately:

~1,600 hands/sec

in that specific test environment.

Those numbers do not prove that the parser is perfect.

They demonstrate something much narrower and more useful:

in that corpus and that environment, the observed behaviour met those criteria.

This distinction is essential.

AI can produce the code.

Verification must produce the evidence.

Build, Test, Benchmark, Diff

The pattern repeated itself continually.

After a change:

build

→ tests

→ lint

→ benchmark

→ inspect diff

Not every step is always necessary.

It depends on the type of change.

But the principle remains:

the model’s response is not the acceptance criterion.

If I modify a query, I examine the results and the query plan.

If I modify the parser, I use real inputs.

If I work on the frontend, I verify behaviour, the build and regressions.

If I refactor, I check that the diff has not changed the semantics.

The faster generation becomes, the more disciplined verification must become.

The Diff as a Unit of Control

With AI, it is easy to obtain very large patches.

And a large patch can look productive.

But every added line expands the space we need to understand and verify.

I therefore began to prefer smaller, intentional changes.

One problem.

One boundary.

One patch.

One verification.

Then the next step.

It is not always the fastest way to generate code.

It is often the fastest way to keep the system understandable.

Sometimes the Best Solution Is to Remove

Generative tools have a natural ease with adding things.

New abstractions.

New helpers.

New components.

New layers.

But improving a system does not necessarily mean increasing what it contains.

During some refactoring work, the most useful question was not:

“what can we add?”

It was:

“what can we remove without losing behaviour?”

Duplicated code.

Paths that are no longer used.

Logic that has become redundant.

Unnecessary eager loading.

Accidental complexity.

Frontend lazy loading, for example, was not merely about adding a technique.

It was about deciding what not to load until it is needed.

Subtraction is as much a part of engineering as generation.

AI as a Reviewer

One of the most interesting changes came when I stopped using AI solely to write code.

It can also be very useful as a reviewer.

But the question matters.

Asking:

“is this implementation good?”

can easily invite confirmation.

Far more useful:

“look for regressions.”

“find edge cases I am not covering.”

“what assumptions am I making?”

“where could the semantics change unintentionally?”

“look for dead code or duplication.”

“which part of this solution is the most fragile?”

In this way, AI is not merely a generator.

It becomes a tool for creating critical friction.

And that is often worth more than a few hundred lines produced more quickly.

Separating Design from Coding

Another pattern that worked well was separating two moments.

Design first.

Then implementation.

For non-trivial changes:

  1. analyse the problem;
  2. reconstruct the existing system;
  3. propose the approach;
  4. assess trade-offs and risks;
  5. define the acceptance criteria;
  6. only then modify the code.

This makes it easier to stop a wrong direction before it becomes a patch hundreds of lines long.

With a fast coding agent, the ability to say “do not implement yet” becomes surprisingly important.

A More Disciplined Workflow

Over time, my workflow became something like this:

Problem

↓

Read existing system

↓

Define scope

↓

Define constraints

↓

Define acceptance criteria

↓

AI analyses / proposes

↓

Review design

↓

Implement

↓

Build / Test / Benchmark

↓

Inspect diff

↓

Accept or iterate

An AI-assisted engineering workflow from defining the problem through verification and iteration

Seen in this way, AI occupies an important part of the process.

But it does not own the process.

For me, this is the fundamental difference.

Guardrails Do Not Slow AI Down

Scope.

Constraints.

Tests.

Architecture rules.

Small diffs.

Review.

Acceptance criteria.

They might look like obstacles to speed.

In reality, they make it possible to use that speed without turning it into entropy.

AI-assisted engineering guardrails: scope control, small diffs, tests, architecture rules, review and human ownership

The coding agent can rapidly explore many possibilities.

The guardrails determine which of those possibilities are acceptable in the real system.

The more capable the model becomes, the less sense it makes to compete with it on typing speed.

It becomes more important to be good at:

  • defining the problem;
  • providing context;
  • establishing boundaries;
  • recognising trade-offs;
  • verifying results;
  • deciding when to stop.

Context Becomes Part of Engineering

Working in this way reveals another consequence.

The context provided to AI is no longer simply “prompt engineering”.

It is part of the engineering work.

Architecture.

Conventions.

Invariants.

Previous decisions.

Contracts.

Tests.

Constraints.

Objectives.

If the model does not know these elements, it can produce code that is locally correct and globally wrong.

This means that the quality of documentation, the clarity of boundaries and the readability of the system become even more valuable.

An understandable codebase does not only help people.

It also helps the tools that work alongside them.

From Vibe Coding to AI-Assisted Engineering

I do not believe vibe coding is necessarily something to avoid.

It is extraordinary for:

  • exploring;
  • prototyping;
  • learning;
  • quickly testing an idea;
  • building a first version.

The problem arises when the same operating model is transferred unchanged to a system that must be maintained.

As the software grows, so does the cost of wrong decisions.

At that point, a transition is needed.

From:

“let us see what it produces”

to:

“we know what must change, what must not change and how we will demonstrate that the change is correct.”

That is where, for me, we begin to talk about AI-assisted engineering.

AI Accelerates Execution. Ownership Remains Human.

The most important lesson I take from this is not about a framework, a model or a tool.

It is about responsibility.

I can delegate a growing share of execution to AI.

I can have it read code.

Propose architectures.

Write tests.

Generate patches.

Analyse queries.

Look for regressions.

But I cannot delegate ownership of the system to it.

Someone still has to decide:

  • what we are building;
  • why;
  • which trade-offs we accept;
  • which risks we do not;
  • what evidence we consider sufficient;
  • when a change can enter the product.

And this is probably the most interesting change AI has introduced into software development.

It does not make engineering less important.

It shifts its value from execution to judgement.

The rule I take with me is this:

use AI to accelerate execution, not to outsource judgement.


Originally published on LinkedIn on 20 September 2026. This edition is part of Lead From Tech Insights.

Read the original post on LinkedIn

← Back to all Insights