THE COMPLETE PROMPT LIBRARY · 392 PROMPTS
Every prompt from the Senior Architect & Engineer Vibecoding Prompt Playbook — 392 copy-ready AI prompts for software engineers, searchable and ready to use in Tanzania, Kenya, Uganda or anywhere else.
HOW TO USE THE LIBRARY
Text in [square brackets] is a slot for your own context. Replace it with a real requirement, file path, error message or constraint before you send the prompt. Then ask the agent for the evidence you would need to trust the answer.
Turn this request into a precise spec: [request]. List functional requirements, non-functional requirements, explicit non-goals, and open questions. Mark anything you had to assume.
Why it worksSeparates what is known from what is guessed, so assumptions get challenged before they become code.
Before writing anything, ask me the ten questions whose answers would most change the design of [feature]. Rank them by how much rework a wrong answer causes.
Why it worksFront-loads the expensive unknowns instead of discovering them mid-implementation.
Here is the ticket: [ticket]. Write the acceptance criteria as Given/When/Then scenarios, including the unhappy paths and the boundary values.
Why it worksForces testable criteria and drags edge cases into the open at planning time.
What is the smallest version of [feature] that delivers the user value? Then list what we are deliberately deferring and what that deferral costs us later.
Why it worksProduces an MVP with an honest price tag on the debt it creates.
Restate this requirement in your own words and tell me where it is ambiguous or self-contradictory: [requirement].
Why it worksCheap ambiguity detector; contradictions surface before they are encoded.
Identify the implicit requirements hiding in this request: [request]. What will users assume works that we have not mentioned?
Why it worksCatches the unstated expectations that generate "but I thought it would…" bugs.
For [feature], list every stakeholder and what each one needs to be true for them to call this a success.
Why it worksPrevents optimizing for the loudest stakeholder and missing the compliance or ops view.
Estimate this work in three sizes: smallest possible, realistic, and with the unknowns resolved. State what drives the spread.
Why it worksMakes uncertainty explicit instead of hiding it in a single optimistic number.
What would make us regret building [feature] in six months? List the assumptions that, if wrong, turn this into a rewrite.
Why it worksSurfaces the load-bearing assumptions while they are still cheap to test.
Decompose [epic] into vertical slices that each ship independently and are individually valuable. Order them by risk retired per unit of effort.
Why it worksProduces a delivery plan where every slice de-risks the next one.
Here is the requirement and here is the existing system: [context]. What does this requirement conflict with, and which existing behavior must change?
Why it worksFinds the collisions with current behavior before they become regressions.
Write the one-page design brief for [feature]: problem, users, success metric, constraints, non-goals, and the decision we are asking for.
Why it worksGives you the artifact that gets a decision made in a review meeting.
What is the definition of done for [task], including observability, docs, migration, and rollback — not just "code merged"?
Why it worksExpands "done" to include everything production actually requires.
List the failure modes of this requirement as written: [requirement]. For each, propose a sharper wording.
Why it worksTurns a fuzzy requirement into a precise one by attacking it first.
Given these constraints [constraints], what is explicitly out of scope, and what would we have to give up to bring it back in?
Why it worksMakes scope trade-offs visible instead of silently absorbing them.
Draft the questions I should ask the requester of [feature] to close every gap in this description.
Why it worksGives you a ready-made clarification agenda for the next conversation.
Turn this vague goal into measurable success criteria: [goal]. Include the metric, the target, and the time window.
Why it worksConverts aspiration into something you can actually verify after launch.
What is the blast radius of [feature] if it behaves exactly as specified but the specification is wrong?
Why it worksSeparates "did we build it right" from "did we build the right thing".
Compare this request against what the system already does: [request] + [context]. Is this a new capability or a variant we should generalize?
Why it worksPrevents a fourth near-duplicate feature where one abstraction would do.
Write the risk register for [initiative]: risk, likelihood, impact, early warning signal, and mitigation owner.
Why it worksProduces a living artifact that turns vague worry into tracked, owned risk.
Give me 2–3 architecture options for [problem]. For each: components, data flow, failure modes, operational cost, and the condition under which it is the wrong choice.
Why it worksOptions with explicit disqualifiers beat a single confident recommendation.
Design [system] and then argue against your own design. What breaks first at 10x load?
Why it worksForces the agent to stress-test its own proposal instead of defending it.
What are the boundaries of this service? List what it owns, what it must never own, and where the seams are.
Why it worksClear ownership boundaries are what keep a service from becoming a distributed monolith.
Draw the sequence diagram for [flow] in text form, including the failure path at each step and what the caller sees.
Why it worksMakes the unhappy paths first-class citizens of the design.
Where should this logic live: [logic]? Give me the argument for each candidate layer and the coupling cost of each.
Why it worksTurns a placement argument into an explicit coupling trade-off.
Identify the single points of failure in this design: [design]. For each, what is the blast radius and the cheapest mitigation?
Why it worksFinds the components whose failure takes the whole system down.
What is the consistency model here, and what does the application have to do to tolerate it? Be specific about read-your-writes and ordering.
Why it worksConsistency assumptions are where distributed systems quietly break.
Propose the interface contract for [component]: methods, inputs, outputs, error semantics, idempotency, and versioning strategy.
Why it worksAn explicit contract is what lets two teams build in parallel without integration hell.
What would this architecture look like if we had to run it with a team of three? What would we cut?
Why it worksReveals the operational complexity that a large-team design hides.
Compare synchronous vs asynchronous handling for [flow]. Give me latency, failure semantics, complexity, and debuggability for each.
Why it worksMakes the sync/async decision on evidence rather than fashion.
Design the data model for [domain] and show me the access patterns it optimizes for and the ones it makes painful.
Why it worksData models are access-pattern decisions; naming the losers prevents surprises.
What are the extension points in this design? Where will the next three features attach, and does that require a change to the core?
Why it worksTests whether the design is actually open for extension or just claims to be.
Here is the current architecture: [context]. What is the smallest change that solves [problem] without a rewrite?
Why it worksGuards against the reflexive rewrite that senior engineers should resist.
Identify the coupling in this design: [design]. Which modules change together, and how do we break that dependency?
Why it worksChange-coupling is the real measure of a design's health.
What are the backpressure and overload strategies for [system]? What happens when the queue is full?
Why it worksOverload behavior is a design decision, not an accident to be discovered in an incident.
Propose the deployment topology for [system]: instances, regions, state, and what a rolling deploy does to in-flight requests.
Why it worksConnects the logical design to what actually happens during a release.
What is the migration path from the current design to this one, step by step, with the system shippable at every step?
Why it worksAn architecture you cannot migrate to incrementally is not a plan, it is a wish.
Review this design against the twelve-factor and cloud-native principles: [design]. Where does it violate them and does it matter here?
Why it worksApplies a known checklist without treating it as dogma.
What are the three hardest questions a skeptical staff engineer would ask about this design, and what are the honest answers?
Why it worksPre-runs the design review you are about to face.
Given these quality attributes [attributes], rank the architectural tactics by cost-effectiveness for this system.
Why it worksTies architecture decisions to the attributes the business actually cares about.
Prefer to learn in order? Start the course and work module by module . For a smaller project, begin with the free Vibe Coding course. For everyday prompting, try Your first steps with AI & prompting.