Hand AVP a specification.
Get back verified silicon.
AVP reads an authoritative spec, turns it into intent, generates the design from that intent, then debugs and regresses it to a signed verdict — where every result traces back to the document. No assumptions filled in. No hand-written RTL.
Four moves, one specification
AVP doesn't test a design someone else wrote — it reads the specification, builds the design, and proves it. Each move hands the next a piece of structured, traceable evidence.
Read the specification
The document becomes a feature-level intent, where every item carries the exact line it came from. Anything the spec doesn't state is held OPEN — never invented.
Generate the design
The intent is turned into the design itself — generated, not hand-authored, and rebuilt whenever the intent changes so the source of truth is always the spec.
Simulate & debug
The design is exercised against what the spec requires. When something diverges, it is diagnosed to a root cause and the fix is proposed — landing in the generator, not the file.
Regress & sign off
Every requirement is reconciled — passed, failed, blocked, or not-run — and the whole must close. The result is a signed verdict you can diff, not a claim you take on trust.
The fix goes back to the source
When debugging finds a real defect, the correction doesn't patch the output — it goes upstream into what generated it, and the design is rebuilt. Each pass through the loop leaves the platform able to do the next one better.
- 01Nothing is seeded. Every feature and expected result traces to a line in the document — or it is held OPEN, never guessed.
- 02A pass was checked. Real behaviour is compared against what the spec requires, and deliberately injected faults must be caught.
- 03The fix goes upstream. A repair lands in the generator and the design is rebuilt — the generated design is never hand-edited.
- 04The verdict closes. The full requirement set reconciles and is signed. A malformed result is rejected, not waved through.
Every verdict means exactly what it says
AVP labels the truth of each result. A win is a win, a gap is a gap, and a correct design is not dressed up as a repair. The gates enforce it.
TRACED Back to the document
Every feature and result points to the line of the spec it came from. Where the document is silent, AVP holds the item OPEN instead of assuming an answer.
CHECKED A pass is earned
Real behaviour is compared against the requirement, and deliberately injected faults have to be caught. Building cleanly is not a result.
REPAIRED AT SOURCE The generator, not the file
When the loop finds a real defect, it corrects what produced the design and rebuilds — so the fix is permanent and the output is never hand-edited.
FAIL-CLOSED Drift is rejected
Versioned contracts guard every hand-off. A result that doesn't match its declared shape stops the run — it is never quietly signed off.
One document. One command.
# the whole loop, from the spec $ avp run --spec design_spec.pdf # or one move at a time $ avp build # spec → intent → design $ avp debug # simulate + diagnose $ avp regress # reconcile + sign off ✓ SIGNOFF PASS → run/signoff.json # signed, diffable
Request access
AVP is an installable package with a fail-closed command line. You bring the authoritative document; AVP turns it into a generated, verified design with a signed, reproducible trail.
What AVP is not. Not a replacement for your signed-off, human verification, and not an oracle that fills in what a spec left unsaid. It builds and verifies what the document actually specifies, holds the rest OPEN, and hands you a signed, reproducible trail — so real work starts from evidence, not a blank page.