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\".

Adrien MaretCTO
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
- Vibe coding and vibe engineering: two different methods using the same tools
- Seven prompts to guide coding agents better
- Clarify the intent
- 1. Have the agent interview you before it codes
- 2. Require an implementation plan, with the tests inside
- Spark the agent's creativity by exploring several options
- 3. Have it explore 10 screen layouts and pick the best 3
- Demand proof at the verification stage
- 4. Have the model simulate the code's execution in its reasoning
- 5. Have the code reviewed by another family of AI
- 6. Have the agent run the UI tests
- Keep the specifications as the source of truth
- 7. Record the specifications and the decision log in the project
- Going further: frame the agent with guardrails and real operations
- Start with your next feature
Maleus applies these seven prompts by default, from the first question to production.
Recent articles
- PerspectivesNovember 6, 2026The democratization of software in the age of AI
- EngineeringOctober 27, 2026The Maleus ADLC: from idea to production with agents
- EngineeringMay 26, 2026From Emacs to Cursor, the end of your IDEs is near
- EngineeringMay 15, 2026Context engineering: why one CLAUDE.md isn't enough


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.
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.
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.
The prompt to copy
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
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.
The prompt to copy
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
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)
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
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
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:
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.