Not speed.Direction.
AI-assisted requirements specification for developers — triage, analysis, and plan before code.
Your team ships code every day. Some of it will be rewritten — not from lack of skill, but from lack of clarity before starting. AI Spec Protocol structures what AI alone cannot: the right decision, before the wrong line.
Not another framework. Process intelligence.
Your team got faster. But speed in the wrong direction is expensive. A poorly specified card found on sprint day three can invalidate 30% of the squad's effort.
Teams without structured process waste up to 30% of capacity on rework caused by inadequate specification.
After 6 sprints of consistent adoption, the same teams report reduction in this metric.
From 15 minutes (low risk) to 90 minutes (critical integrations). Less than the cost of not having it.
Estimates based on team practice and reported consistent protocol adoption — not a guarantee of results.
The problem almost never shows up under its real name.
The card looks clear. The developer starts with confidence. Halfway through implementation, an implicit rule appears, a dependency was forgotten, or a product decision was never formalized. Code stops. The PO is pulled in mid-sprint. The answer is partial, the interpretation is human, and rework lands on the calendar under another name: adjustment, alignment, scope change.
Monday: the card looks ready.
Wednesday: the gap appears in code.
Thursday: the PO answers under pressure.
Friday: the team rewrites what seemed right.
The problem was not speed. It was clarity before code.
Seven skills. One direction.
Each skill has a unique role. Each demand follows the right path for its risk level — no unnecessary ceremony, no silent gaps.
Mandatory entry. Classifies demand type and risk.
Technical analysis. Crosses card with codebase, updates spec.md.
Definition of Ready. Readiness proportional to risk.
Product communication. A/B co-specification for the PO.
Revalidation. Closes gaps after PO response.
Planning. Generates and refines plan.md and tasks.md.
Exception mode. Formal bypass with recorded risk.
Spec Protocol onboarding in Cursor, Claude Code, or a compatible IDE — flow, skills, and CLI.
Same demand. Two completely different outcomes.
Without a protocol, the team talks to AI on the fly, accepts plausible output, and discovers questions during implementation. With AISP, the demand starts with triage, hypotheses are marked, decisions are recorded, and the plan reaches code with enough direction to execute without walking in the dark.
Without a protocol
- The card looks good enough.
- AI answers with confidence, not evidence.
- Questions appear after coding has already started.
- The conversation gets lost in chat, calls, or oral memory.
- The PO enters late, under pressure, without structured context.
With AISP
- The demand is classified by type and risk.
- Every unproven inference becomes HYPOTHESIS.
- Critical gaps appear before implementation.
- Decisions live in spec.md, plan.md, and tasks.md.
- The PO responds to options and impact, not vague questions.
This is not more ceremony. It is fewer wrong turns.
Three files. Full traceability.
Decisions, not lost chats. Everything in the repo, versioned and readable by the dev, the AI agent, and the PO who joined two weeks ago.
# Objective Implement Stripe webhook handler for subscription updates. # Business rules - On payment failure → immediate downgrade to free tier. - [HYPOTHESIS] Existing user ID matches Stripe customer metadata. - [CRITICAL] Idempotency key required — duplicate events must be safe. # Metadata Risk level: HIGH Status: PARTIALLY READY Owner: @backend-team
Less random chat. More reasoning distributed through the workflow.
Most teams use AI as an improvised counterpart: ask, repeat, correct, try again. AISP changes that relationship. Instead of relying on manual prompt engineering for every demand, you trigger skills with clear roles, known artifact structures, and a workflow that forces hypothesis, evidence, risk, and decision to stay separate.
Loose AI chat
Implement the Stripe webhook handler.
Sure! Here is a complete solution...
Wait — what about idempotency?
Good point. Try this instead...
What was the card context again?
AISP workflow
AI amplifies analysis. The protocol organizes thought. The developer decides.
AISP solves problems the team feels but rarely names.
Not every loss appears as a bug, delay, or reopened card. Some of the cost lives in the mental load of analyzing ambiguous work, dependency on informal memory, silent friction with the PO, and the risk of agents operating without enough context. The protocol works exactly in that invisible layer.
Cognitive load
Deep card analysis is expensive attention work. Without structure, it is half-done or skipped.
Fragile onboarding
When decisions do not live in the repo, the new developer depends on whoever remembers the story.
Mediation that does not scale
Many teams depend on the same developer who knows how to talk to the business. AISP turns that into an explicit part of the workflow.
Agent without context
Without a clear tasks.md, an agent tends to introduce unintended scope changes.
The invisible also costs sprint time. The protocol makes that cost manageable.
Different roles. One common problem.
AISP is not for only one kind of professional. It organizes the interface between development, product, and AI-assisted execution, so the gain appears at different points of the workflow for each role.
Dev
Stop starting work with the feeling that the real requirement will surface halfway through.
PO
Receive structured decisions with impact described, instead of loose questions dropped into chat during the sprint.
Tech Lead / EM
Scale consistent technical scrutiny without depending on the same senior every time.
Team using AI in the IDE
Move out of conversational improvisation and into versioned context with an explicit workflow.
Less doubt along the way. More confidence to implement.
When the workflow forces risk classification, hypothesis marking, decision recording, and readiness validation, the work feels different. You no longer need to steer a loose AI conversation to discover what should have been thought through earlier. You ship less from improvisation and more from direction.
Clarity is productivity too.
Now that the flow is clear, the question stops being “what is AISP?” and becomes “where does it make sense to start?”.
From ambiguous card to conscious implementation.
Chapter by chapter, from the invisible cost of ambiguity to the full conscious implementation flow. The guide that turns uncertainty into manageable risk — with recorded decisions and less rework.
Full flow in 6 steps — next sprint.
Practical online lessons. You leave with the full flow running in Cursor, Claude Code, or a compatible IDE — triage, analysis, DoR, PO communication, and an executable plan in hand. Sign up and watch the first lesson free: triage, analysis, decisions, plan, and implementation with spec.md, plan.md, and tasks.md.
Integrated with any terminal.
Install via NPM, initialize skills, generate artifacts, and validate readiness directly in the repo you already work in.
You do not need to adopt everything at once.
The protocol was designed to be proportional to risk. Simple demands do not need heavy process; critical demands cannot be treated lightly. That lets you start small, validate value, and expand with maturity.
Triage before code
Use spec-protocol-triage, create a minimal spec.md, and stop starting work in the dark.
Full refinement for medium-risk work
Analyze, validate readiness, involve the PO when needed, and reach plan.md with better criteria.
Mature process operation
Add metrics, formal exception mode, revalidation, and artifacts prepared for agents and pipelines.
Start with what fits the next sprint. Expand when the gain becomes visible.
More clarity.Less rework.
You have seen the contrast, the roles, and the adoption levels. Now choose where to start — protocol, guide, or CLI.