MaleusMaleus
EngineeringNovember 10, 2026· 10 min read

From vibe coding to vibe engineering in 7 prompts

Seven copy-ready prompts for your coding agent or app builder, to go from \"it seems to work\" to \"I know why it works\".

Key takeaways

  • Vibe coding keeps whatever seems to work without knowing why it works; vibe engineering moves just as fast while staying accountable for what ships.
  • Seven prompts change how the agent works: it asks its questions, plans with the tests, compares several options, simulates the run, gets reviewed, tests like a user and lets the specs decide.
  • Each prompt is ready to copy and works with a coding agent as well as with an app builder.
  • Prompts are not enough on their own: automated controls, deployment and maintenance remain essential, and Maleus builds them into the platform.
On this page

Your coding agent has just finished and announces it with confidence: "done, it works". Most of the time, it has no idea, because it guessed what you wanted, kept the first solution that came to mind and claimed victory without ever trying the application.

In our article on the software explosion, we explained why shipping a first version is not enough to make software. This one is more hands-on: here are seven copy-ready prompts for your agent, to go from vibe coding to vibe engineering, whether you work with a coding agent or with an app builder.

Vibe coding and vibe engineering: two different methods using the same tools

We call it vibe coding when you describe what you want to an AI and keep the resulting application if it seems to work, without looking at how it is built. That is perfect for a prototype or a personal app, but it becomes risky as soon as other people depend on it.

The term vibe engineering was coined in October 2025 by Simon Willison, co-creator of the Django framework, for the other end of the spectrum: professionals who move just as fast thanks to AI, but who stay accountable for what they ship. Between the two, the tool does not change; how you steer it makes all the difference.

SituationVibe codingVibe engineering
Some information is missingThe AI guessesThe AI asks
Before codingJust dive inA plan, tests included
"It works"A claimProof: tests, review, a real user journey
The code and a test disagreeThe AI takes the shortest pathThe specs decide
Good forPrototypes, personal useAnything others depend on

Prompts make the agent better, but you also need controls and real operations, detailed at the end of the article.

Seven prompts to guide coding agents better

If you are in a hurry, this table is enough to get started: each row is a copy-ready prompt, detailed below.

#PromptWhenWhat you ask the agent
1InterviewBefore codingAsk its questions about open points
2Plan with testsBefore codingWrite a plan you review, with the tests for each step
310 layouts, 3 keptDesignCompare ten screen variants before keeping three
4Simulated runVerifyWalk through the execution: normal case, simultaneous actions, error
5Cross-reviewVerifyHave the code reviewed by an AI from another family
6Testing through the UIVerifyReplay the full journey like a real user
7Specs as the source of truthArbitrateCheck specs and decisions before fixing the code or the test

Clarify the intent

An AI that lacks a piece of information does not stop to ask for it: it guesses, and it guesses with great confidence. The first two prompts surface these gaps before the first line of code, when fixing them costs almost nothing.

1. Have the agent interview you before it codes

Every request hides decisions nobody has made yet: who is allowed to do what, what happens when a field is left empty, or whether a mobile version is needed. Left alone, the agent settles them silently, and you discover its choices once the application is built.

The fix fits in one sentence: ask it to put its questions to you before it starts, focusing on the open or uncertain points.

A one-line request hides several decisions: the agent turns them into questions before coding.

The prompt to copy

Before coding, ask me your questions about the open or uncertain points.

At Maleus, this interview is built into the platform: the framing workshop digs into personas, user journeys and business rules with you before any code is written.

2. Require an implementation plan, with the tests inside

Without a plan, the agent discovers the architecture as it codes, and tests come as an afterthought, if at all. With a plan, each step states what it builds and how we will prove it works: unit tests, end-to-end journeys, edge cases.

You review this plan before development starts, because fixing a line in a plan costs far less than fixing a feature. The agent then moves one step at a time and only goes to the next once the tests of the previous one are green.

The prompt to copy
Before writing any code, write an implementation plan and wait for my approval. For each step: what changes, and right below it, its test plan (what we check, how, and the edge cases). Then execute one step at a time and only move to the next once its tests pass.

At Maleus, the implementation plan is written before any line of code, and the tests are planned in it from the start, based on the specifications. We also build Maleus itself with exactly the same method.

Spark the agent's creativity by exploring several options

A screen's design is too often settled on the first proposal that comes along, when a single prompt is enough to put real options on the table.

3. Have it explore 10 screen layouts and pick the best 3

Ask an AI for a screen: it proposes the first layout that comes to mind, and you get attached to it because it is the only one you have seen. To get out of that trap, ask it for ten variants, described element by element, each designed for your real usage situations.

Then have it keep the best three, with its ranking explained. You choose between real options before building anything, which costs a few minutes of reading instead of several rounds of changes on a screen already coded.

Ten layouts of a leave-request screen screened against three real uses, three kept with their rationale.

The prompt to copy
Come up with 10 ideas for positioning the elements of [screen] for the best user experience. For each idea, describe each element and its position relative to the others, in each of these scenarios: [usage scenarios]. Then keep the best 3 and explain your ranking.

Demand proof at the verification stage

"Done, it works" is not proof. The next three prompts replace the claim with a verification, attacking the problem from three angles: reasoning, review and real use.

4. Have the model simulate the code's execution in its reasoning

Some bugs cannot be seen by reading the code line by line, because they come from the sequence of events: two people clicking at the same second, a connection dropping in the middle of a save, a step starting before the previous one has finished.

So we ask the agent to play out the scene in its reasoning, step by step, noting the state of the data after each action, exactly as an experienced developer would at the whiteboard. We call it the flow review simulate.

The prompt to copy
Simulate the execution of [journey or function] step by step in your reasoning: each call, and the state of the data after each one. Do it for the normal case, for two users acting at the same time, and for an error halfway through. List the bugs, edge cases and conflicts you find.

At Maleus, this execution flow review is one of the three automated reviews of every version, dedicated to bugs, simultaneous actions and edge cases.

5. Have the code reviewed by another family of AI

An AI model is bad at catching its own mistakes, because its blind spots come from the way it was trained. A model from another family, for example Claude on one side and GPT on the other, does not share the same blind spots and catches what the first one lets through.

It is the four-eyes principle applied to AI: the reviewer ranks each issue by severity and backs it with the line of code concerned, which makes every comment verifiable.

The prompt to copy (for the reviewing model)
You are reviewing code written by another model. Look first for logic errors, unhandled cases, security flaws and gaps with the request. Rank each issue by severity and back it with the line of code concerned.

At Maleus, cross-review is built into the review of every version: Claude writes, and Alyx, our AI assistant running on GPT Sol, reviews. Alyx never merges on its own; a human makes the call.

6. Have the agent run the UI tests

Green technical tests do not prove that a user can do what they were promised, because each piece can work on its own while the whole does not. Only a real journey proves it: the agent opens the application, clicks like a user and checks that the result shows on screen and is actually saved.

The rule to give the agent is simple: until this journey has succeeded, nothing is done.

The prompt to copy
After each change, test end to end through the interface: launch the application, go through the complete user journey in the browser, and check the result on screen and in the data. A change that has not been tested this way is not done.

At Maleus, this is the agent's default behavior: tests replay user journeys in a real browser, from the click to the saved data.

Keep the specifications as the source of truth

The last prompt is for arbitration, at the moment the agent is most tempted to take a shortcut.

7. Record the specifications and the decision log in the project

Faced with a failing test, the agent has two options: fix the code, or change the test so it passes. Without a reference, it often takes the quickest one, which is rarely the right one, and it does the same when two features contradict each other.

The fix is to write specifications describing how the project must work, and a log of the decisions made, with their reasons. The agent reads them before arbitrating, fixes whatever departs from the specs, code or test, and stops to ask you when they do not settle the question.

The prompt to copy
Before resolving a conflict between two features or a failing test, reread the project specs and the decision log in [folder]. The specs are authoritative: if the code departs from them, fix the code; if it is the test, fix the test. If the specs do not settle it, stop and ask me. After each decision, add it to the log with its reason.

At Maleus, the detailed specifications are the source of truth: when a test fails, the agent goes back to them to know whether it should fix the code or the test.

Going further: frame the agent with guardrails and real operations

These seven prompts make the agent much better, but a prompt remains an instruction: the agent can forget it, misunderstand it, or be hijacked by malicious content. Vibe engineering therefore also requires guardrails that hold even when the agent gets it wrong, and a real life after delivery:

  • Controls enforced by the tooling rather than politely requested from the agent: what it is allowed to read, change and run.
  • Continuous integration, which runs every change through a battery of automated checks before accepting it, whatever the agent says.
  • Lasting tests, which stay in the project and run on every change, instead of vanishing with the session.
  • Security: passwords and keys never exposed, external libraries vetted, vulnerabilities hunted before going live.
  • A sandbox, an isolated space where the agent can touch neither production nor real data if it goes off the rails.
  • Staged deployment, with a test environment, human approval and rollback possible within minutes.
  • SRE-style long-term maintenance: monitoring the application, getting alerted before users notice, handling incidents and updating dependencies.

Prompts make the agent better, controls make its mistakes harmless, and operations make what it built last.

At Maleus, part of these guardrails is enforced by the platform rather than left to the agent's goodwill: risk-graded review, no merge without human approval, production release on human sign-off, and deployment included. Dependency security updates, bug reports and changes are handled in the platform, as we detail in our article on the Maleus development lifecycle.

Covering that whole cycle, from scoping to operations, is what defines an AI software factory, and before choosing how to build, our guide to build or buy, layer by layer helps decide which needs deserve software of their own.

Start with your next feature

You can apply these seven prompts today, with the agent or app builder you already use. Start with the interview and the plan: they are the two that act earliest, before the first line of code, where a fix costs the least.

Share

Maleus applies these seven prompts by default, from the first question to production.