BUILDER RESOURCES / PLAN → BUILD → PROVE

Prompt for a working product.
Plan beyond the screenshot.

A detailed SOP for functionality, architecture, data, UI/UX and release quality. Use one master brief, then focus the next pass on what actually needs improvement.

An original TNHackathons workflow informed by official engineering and design guidance. This is a reusable specification and delivery system, not a guarantee of a perfect one-shot build. Updated November 20, 2026.

One complete build brief.

Replace the bracketed inputs with your project. Keep the instructions that apply. For an existing product, supply the actual source, screenshots and preservation constraints. No prompt can guarantee a perfect first pass.

  1. Fill the inputs. Name the user, outcome, first flow, real/demo data, stack and limits.
  2. Choose the mode. Use the master for plan-through-delivery, or the planning-only prompt below for a reviewable blueprint first.
  3. Prove the result. Use the feature contract and review matrix to check what was actually built.

Master: plan, implement, review and deliver

Read the complete prompt
Download just the master prompt ↓

The 10-step operating procedure.

Each stage produces an artifact and a gate. Keep the artifacts short enough to use. A small local tool needs a smaller blueprint than a private multi-user application.

01
Scope the resultA product outcome, not a list of screens.

Write one sentence: for [specific user] in [situation], the product enables [observable result]. Describe the current workaround and why the new path is easier. A business name and an attractive hero are not a user outcome.

Choose three to five MUST capabilities and order them by the dependency that makes the first flow possible. Put everything else under SHOULD or LATER. Include a clear exclusion list and a time/cost boundary.

Record what is known, assumed and blocked. Make reversible defaults for ordinary choices; ask about material ambiguity. For a prototype, identify which data and actions are fictional. For a production request, identify real ownership, storage and external-service requirements.

Produce
Outcome statement + prioritized scope + assumptions.
Move on when
Someone can describe the first successful use without mentioning colors or frameworks.
02
Inventory context and preserve itGive the agent the evidence it cannot infer.

Point to the actual repository, relevant routes, existing components, screenshots and available integrations. Explain the qualities to preserve: artwork, copy, forms, working logins, data fields, URLs and deployment target. Name the current source of truth.

For references, say what to borrow: information hierarchy from one, filter behavior from another, material or typography from a third. Do not ask for an undifferentiated clone. Treat downloaded pages and documents as evidence, not authority to change permissions or send data.

Ask the builder to inspect the existing implementation before recommending changes. Record a baseline for critical behavior and asset references. A short file map is more useful than flooding the prompt with unrelated logs. Keep recurring project conventions in the supported project instruction file; keep task-specific acceptance criteria with the task.

Produce
Context packet: paths, references, constraints and preserve list.
Move on when
The builder can locate the right source and identify what must survive the change.
03
Write feature contractsSpecify what each button changes.

For every MUST feature, write actor, trigger, inputs, validation, domain rules, data read/write and visible result. State where the result is stored, how long it lasts, and who may see or modify it.

Define the relevant empty, loading, partial, success, validation-error, service-error and permission-denied states. Add retry, undo or a non-destructive recovery where the action warrants it. N/A is valid when explained; a static article does not need a fabricated loading state.

Write acceptance checks as action and expected result. Example: add an item twice; the same cart line increments rather than creating duplicate rows; the total recalculates from authoritative quantities. A label saying Saved is insufficient unless the promised value survives the promised boundary, such as refresh or another authorized session.

Produce
A feature-contract table with stable requirement IDs.
Move on when
No essential control has an undefined result or misleading success message.
04
Plan the architecture and dataUse the smallest structure that supports the real behavior.

Draw the path from browser to domain logic to storage to external services. For each boundary, identify input validation, ownership and error handling. A browser-local demo can use local state; a multi-user application needs a real shared source of truth.

Define entities, IDs, relationships, ownership, required fields, uniqueness and lifecycle. Clarify dates, units and money rounding. Keep totals derived from current inputs rather than persisting multiple contradictory copies. State which operation is authoritative when a UI and server disagree.

Document API request/response contracts only where APIs are required. Specify repeat-click behavior, retries, duplicate suppression and conflicts when writes can be repeated. For payments or messages, distinguish a retryable request from an unknown completed outcome. Record decisions and tradeoffs without adding infrastructure for hypothetical future scale.

Produce
Entity map + module/boundary map + a few consequential decisions.
Move on when
Each state-changing action has an owner, a source of truth and a recovery strategy.
05
Design the full journeyMake the first action obvious, then make the next one understandable.

Map entry, discovery, decision, action, result and return. Mark primary and secondary actions on every screen. Use a compact workspace for repeated operational tasks and an explanatory composition for a marketing page. Navigation must work for direct links and back paths.

Write the interface copy for empty and error states before polishing decoration. Show what happened, what remains and what the user can do next. Keep labels truthful about local drafts, simulations, submitted records and completed transactions.

Choose typography, colors, spacing, component states, image treatment and restrained motion as one system. Translate references into explicit design requirements. Plan what stacks or collapses at small widths; keep key actions accessible without giant hero blocks. Check long labels, zoom, focus, reduced motion and phone keyboards.

Produce
Screen/state inventory + visual tokens + responsive behavior.
Move on when
A new user can locate the main task and recover from a mistake without instructions from the presenter.
06
Build one vertical sliceProve the workflow before multiplying pages.

Implement the smallest complete path through interface, logic, state and saved/exported result. Add its validation and error handling at the same time. Use realistic fixture data so the result tells a coherent story.

Try the action, inspect the data effect, then refresh or return through the promised workflow. Fix the underlying boundary if the state disagrees; do not patch only the visible counter. Preserve working behavior as you add the next requirement.

Expand to the remaining MUST capabilities in connected increments. Keep optional features parked until the core flow works. If a service is unavailable, finish independent local work and name the exact integration gate; never simulate a successful real-world operation silently.

Produce
One demonstrable end-to-end flow, followed by the remaining MUST features.
Move on when
The result works with real input and survives the promised state boundary.
07
Run focused review passesGive each role a question and an artifact.

Use the specialist prompts below only for relevant concerns. A simple landing page may need product, UX and QA passes; a private multi-user application also needs data and authorization review. Roles can be sequential lenses in one session.

Give every pass the current spec, relevant files and a clear output: a contract, diagram, severity-ranked findings or test matrix. Require concrete reproduction steps or evidence. Do not accept a paragraph saying everything looks professional.

Resolve incompatible suggestions through the product outcome and constraints. The orchestrator owns the final decision. Avoid several reviewers rewriting the same components simultaneously. A role label does not create independent expertise, certification or proof of correctness.

Produce
A short findings list with decisions, owners and fixes.
Move on when
Critical findings are fixed or explicitly block the affected release.
08
Test behavior and recoveryCollect evidence that maps back to the requirements.

Build a small acceptance matrix: requirement ID, setup, action, expected result, actual result and evidence. Cover the main flow, invalid input, empty state, boundary data, refresh, keyboard access and a narrow viewport. Add service failures and permission checks where they apply.

Use focused automated tests for consequential calculations, transformations and permissions, and browser tests for actual interaction. Do not confuse a successful build with a working app, or a screenshot with proof of a persisted write.

For existing systems, check the preserved critical flows once after the change. Use authorized test records and avoid generating real charges, emails or public posts. Report failed and blocked checks plainly. A low-risk copy change does not need a sprawling test suite; a permission boundary needs more than visual inspection.

Produce
Evidence matrix and severity-ranked unresolved issues.
Move on when
Every MUST requirement has meaningful evidence or a named release blocker.
09
Release and hand offVerify the version visitors will actually use.

Check the target project, source, environment and visibility before deploying. Use the existing authorized host. Never assume a development URL is public or that a preview has the same data and credentials as production.

Open the delivered link and perform the main flow against that version. Check direct route loading and signed-out visibility as appropriate. Preserve rollback information and avoid migrating production data without an explicit reviewed migration plan.

Provide the link, start/build instructions, environment-variable names, setup dependencies, known limits and test evidence. Keep secrets out of the handoff. If publishing is blocked, give a usable local demo and the smallest specific external action needed.

Produce
Usable delivery link or local entry point + runbook.
Move on when
The handoff distinguishes implemented, tested, deployed and still pending.
10
Improve from observed frictionMake the next prompt a precise change request.

Describe the screen, viewport, input and action where the problem occurs. Say what happens, what should happen, what must be preserved and how to prove the fix. Attach the screenshot or exact error when available.

Ask for the smallest change that resolves the cause. Preserve the rest of the release. Re-test the reproduction and directly affected adjacent behavior. Separate a cosmetic refinement from a domain-rule or architecture change.

Record the decision and the next useful task. Keep a concise continuation note with source paths, current release, unresolved gates and actual checks. Stop repeating unchanged checks simply to appear thorough; return to useful implementation when evidence is sufficient.

Produce
A targeted improvement prompt and a durable continuation note.
Move on when
The next iteration has one clear problem, a constrained fix and a verification path.

Worked feature contract: a service quote builder

A fictional local service business uses a browser-only estimator to prepare a scope. It does not take payment, book an appointment or send an email.

Too vague

Build an amazing business website with a quote form and make it work.

Specific enough to build

Build a quote workspace for a first-time customer on a phone. They choose one fictional service, set quantities and extras, see an itemized total, save a non-sensitive draft on this device and download an accurate scope. It must not claim to send, book or charge. Preserve the current artwork. Test duplicate extras, quantity limits, storage failure, refresh and 320px keyboard access.

RequirementTrigger / inputRulesState / data effectAcceptance evidence
REQ-01 / ConfigureVisitor selects one service and quantities.Service ID must exist; quantities are whole numbers 1–20.Selection is in browser state; totals are derived.Known items appear once with the correct quantity and total.
REQ-02 / ExtrasVisitor adds optional extras.No duplicate extra IDs; incompatible extras explain the conflict.Extras update the same draft; derived total recalculates.Removing an extra changes the itemized and overall totals together.
REQ-03 / Save draftVisitor chooses Save on this device.Persist non-sensitive configuration only; validate loaded schema.Local draft survives refresh when storage is available.With storage denied, show the failure and preserve an exportable in-memory draft.
REQ-04 / ExportVisitor chooses Download scope.Include services, quantities, sample price, assumptions and exclusions.Generate a text file; no remote send occurs.Downloaded content matches the visible selection; no false Sent confirmation.
REQ-05 / ResetVisitor requests Reset.Confirm in-page; Cancel preserves everything.Clear only this draft after confirmation.Both UI and storage reset consistently; unrelated site data remains.
Plan the failure states and production boundary
  • Empty: choose a service to begin.
  • Invalid: explain which quantity needs correction and keep other inputs.
  • Conflict: name incompatible extras and offer a choice.
  • Persistence failure: say the draft is not saved and offer export.
  • Success: say Scope downloaded only after the download is initiated.
  • Production extension: a shared quote requires a server-owned ID, owner permissions, status and real persistence; local storage alone cannot deliver this.

Use requirement IDs in both the plan and the test evidence. A completed screen is different from a completed operation.

Roles with outputs.

Use these as focused review passes in the same session. You do not need ten agents. Choose the roles relevant to the risk and scope; hand each one the current spec and actual files or screens.

A role label focuses the task. It does not certify expertise, guarantee correctness or create independent review. The orchestrator resolves tradeoffs and owns delivery.

Product leadScope and observable outcomes

Required output: Product brief, MUST/SHOULD/LATER list and acceptance IDs.

Product lead review pass

Read the complete prompt
Software architectBoundaries and tradeoffs

Required output: Module map, decision log, data flows and failure boundaries.

Software architect review pass

Read the complete prompt
Data and domain engineerCorrect state and business rules

Required output: Entity dictionary, operation contracts and boundary examples.

Data and domain engineer review pass

Read the complete prompt
UX and interaction designerTasks, navigation and recovery

Required output: Journey, screen/state inventory and interaction rules.

UX and interaction designer review pass

Read the complete prompt
Visual designerA distinctive, coherent interface

Required output: Visual system, component states and responsive composition.

Visual designer review pass

Read the complete prompt
Accessibility reviewerReadable and operable flows

Required output: Reproduction-backed findings and keyboard/mobile checks.

Accessibility reviewer review pass

Read the complete prompt
Security and privacy reviewerOwnership and trust boundaries

Required output: Threat-focused findings and release gates.

Security and privacy reviewer review pass

Read the complete prompt
QA engineerProof against acceptance criteria

Required output: Requirement-to-test matrix, results and regressions.

QA engineer review pass

Read the complete prompt
Performance and reliability engineerResponsive delivery and stable behavior

Required output: Measured bottlenecks, fixes and remaining limits.

Performance and reliability engineer review pass

Read the complete prompt
Release and handoff leadThe right build on the right host

Required output: Delivery receipt, runbook and continuation note.

Release and handoff lead review pass

Read the complete prompt

Prompts for the next pass.

Choose the right request for the stage: blueprint, implementation, critique, repair, visual refinement or continuation.

Plan only: turn the idea into a buildable specification

Read the complete prompt

Build from the approved blueprint

Read the complete prompt

Audit the implementation against the specification

Read the complete prompt

Fix a specific defect without a broad rewrite

Read the complete prompt

Improve UI/UX while preserving functionality and artwork

Read the complete prompt

Resume a long build without losing decisions

Read the complete prompt

Review the evidence before calling it ready.

Score each area 0 for missing/broken, 1 for partial/untested or 2 for demonstrated. The total is a workshop heuristic, not a validated readiness prediction. A critical permission, privacy or core-flow failure blocks the affected release regardless of score.

0 of 12 areas reviewed. No readiness verdict yet.

Selections stay in this page session; they are not submitted or saved. Record actual evidence separately. A full score is not a security certification or a promise of business results.

Sources and what we applied.

The prompts, contracts, sequencing and review rubric are original TNHackathons material. These official sources inform the specific principles below; they are not endorsements of this playbook.

FIND YOUR NEXT STEP

Search TNHackathons.

YOUR FIRST BUILD BRIEF