Build a test suite that fails for real reasons, not green decoration — coverage across unit, integration, and edge cases, then a review for the gaps.
Ask an AI to write tests for a file and you get a wall of assertions that cover the happy path and little else — they pass, they look thorough, and they'd miss the bug that actually ships. Tests only earn their maintenance cost if they fail when something is genuinely wrong. That takes understanding the behavior before writing assertions, building coverage in the right layers, and deliberately hunting the edges instead of restating the obvious.
Each step uses an existing NewPrompt tool, pre-filled by a matching resource. Open the resource to read it, or jump straight into the tool with the inputs ready.
Pin down the behavior worth testing
Get the AI to state, in plain terms, what the code is supposed to do — the rules, the inputs that matter, the outputs that count. Assertions written without this just freeze whatever the code currently happens to do.
Cover the core with unit tests
Start where bugs are cheapest to catch: isolated unit tests for the core logic, one behavior per test, fast to run.
Test the seams with integration tests
Unit tests miss the wiring. Add integration coverage — and end-to-end where it earns its keep — for the boundaries: the database call, the API contract, the place two modules meet.
Hunt the edges
Bugs live at the boundaries: empty, huge, duplicate, concurrent, malformed. Have the AI enumerate the edge and failure cases the happy-path tests skipped.
Review the suite for blind spots
Turn the review lens on the tests themselves: what behavior is still uncovered, which tests assert nothing useful, and where a passing test gives false confidence.
A layered test suite — unit, integration, edge — written against stated behavior and reviewed for gaps. The tests fail when something is genuinely wrong, which is the only property that makes them worth keeping.
A test-case prompt spits out assertions for code you paste in; this workflow decides what's worth testing first, then builds unit, integration, and edge coverage against that intent and reviews the suite for gaps. The output is a layered suite that fails for real reasons, not one batch of happy-path tests.
A layered test suite spanning three levels — unit tests pinning the core logic, integration tests for the seams where components connect, and edge-case tests for empty, huge, malformed, and concurrent inputs — plus a review naming the behavior still uncovered and a short list of what to add.
Work the five steps in order in your own AI tool. Start by having the AI state the intended behavior, then generate unit, integration, and edge tests layer by layer, and finish with the review step. You paste each batch into your test runner, run it, and fix or keep as you go.
Run the suite and confirm tests fail for the right reasons — mutate the code or break an input and check the relevant test goes red. Step 5 turns the review lens on the tests, flagging assertions that check nothing and passing tests that give false confidence. The pass or fail call stays yours.
Tests written without knowing the intended behavior just freeze whatever the code does now, bugs included. Stating the intended behavior first means a failing test signals a real problem, not a deliberate choice.
Skip what doesn't apply. Pure logic might only need units and edges; a module full of I/O leans on integration. The review step is the one to always keep — it's what tells you what you missed.
Complete build journeys that include this workflow as a stage.
The full path from idea to a shipped SaaS MVP — define and scope the requirements, design the architecture, API, and data model, then build it reviewed, tested, secured, cost-controlled, and deployed.
The full path to a backend you can put clients on — define the requirements, design the architecture, API contract, data model, and access control, then build it reviewed, tested, secured, and shipped.
The full path to taming an inherited codebase — understand it, document its architecture, pin its behavior with tests, then refactor, modernize, review, speed up, and ship it without breaking what works.
The full path to a two-sided platform — define the buyer-and-seller requirements, model the data, design the API, build roles and permissions, wire integrations, design the UI, then test, secure, and ship it.
The full path to a store you own end to end — model the catalog and orders, design the storefront and checkout, add customer accounts and payments, then secure it, test it, and ship.
A complete AI-assisted review pass — not one prompt — that ends with ranked findings, tests guarding behavior, and a refactor plan when one is warranted.
The order that actually finds bugs instead of guessing at them — so you end with a verified fix, not a plausible one that quietly returns next week.
Restructure code you own without breaking it — change only what's worth changing, and prove with tests and a diff that behavior held.
Cross the gap between 'tests pass' and 'safe in production' — assess release readiness, plan the deploy and its rollback, and set up the monitoring and launch checks before you ship, not after.