Generative Specification · Diagnostic

What does a GS-disciplined codebase look like?

New AI sessions start producing correct output in 30 seconds, not 30 minutes
Architectural decisions from 6 months ago are visible and enforced today
A new engineer contributes meaningfully on day 1, not week 3
Production incidents from implicit inter-system assumptions are structurally prevented
AI generates code that matches your codebase's architectural style on the first attempt
When a senior developer leaves, their decisions stay — in auditable artifacts, not in memory

These are the outcomes the seven specification properties are designed to produce. They are the method's claims, not measurements on your code. The method is published, with its experiments and their limits, at genspec.dev; the studies are small and written by the method's author, so they are published to be re-run.

Below are the 25 structural capabilities your codebase gains when GS is applied — and the 25 failure modes the same properties prevent.

The paid on-ramp

Readiness Assessment — $5,000

Fixed scope, one codebase, read-only under NDA. I run Generative Specification over your codebase and hand you back a real assessment, not a sales call:

A scored report on the Decagon, the ten-property standard: a letter per property, the evidence behind each, and a maturity level (L1 to L5)
The specific structural risks an AI assistant will amplify in your code as it is today
A prioritized remediation roadmap — what to change first, and why
Two reports: a short executive read and a detailed technical one

The full $5,000 is credited toward Remediation or the Forge if you proceed within 90 days. All engagements →

Book a conversation to scope it →

Book a free 30-min discovery call → 30-second self-test ↓

pragmaworks.dev/audit

The 25 capabilities GS builds

Structural acquisitions — permanent, not maintained

Each capability is a structural acquisition — something your codebase gains permanently, not a process you have to maintain.

💎 Transformative — alters the category of work your team can take on

#	Capability	What it means in practice
1	Cross-Session Architectural Coherence	Code generated in any AI session is structurally consistent with all previous sessions. The specification is the persistent referee.
2	Stateless Derivability	A new AI session — or a new engineer — derives the correct implementation from artifacts alone. No verbal handoff needed.
4	Explicit Inter-System Contracts	Every interface between systems is written and enforced. The Mars Climate Orbiter failure mode is structurally eliminated.
12	Specification-Bound Verification	The test suite verifies behavioral contracts against real execution — not just that code compiles.
14	Stateless Knowledge Transfer	Team rotations, AI session resets, onboarding — all handled by the spec. Oral tradition becomes an artifact.
18	Sustainable Formal Discipline	The system enforces SOLID, TDD, and clean architecture automatically — not through cultural pressure.
22	Spec-Level Security	Consequence classification is written. Irreversible operations have confirmation gates. Structural, not procedural.
24	Inverted AI Dependency	AI executes against your specification, not against its prior distribution. You direct the model; the model doesn't direct you.

🚀 Amplifying — multiplies the capacity of existing work

#	Capability	What it means in practice
5	Derivable Project Knowledge	Any engineer or AI session can reconstruct the full project context from artifacts alone.
6	Persistent Session Memory	Context established in one session is available in every subsequent session — without re-narration.
9	Behavioral Verification	Tests prove what the system does under real conditions, not just that it compiles.
15	Visible Technical Debt	Debt is tracked in auditable artifacts. The AI knows it exists. Remediation is planned, not discovered.
21	Structured Prompting	The specification is the prompt. Model-agnostic, version-stable, reproducible across any AI executor.
25	End-to-End Lifecycle Automation	From spec to staging to production monitoring — every tier of the lifecycle governed by the same artifact set.

⚙️ Structural — removes a recurring tax on the team's time

#	Capability	What it means in practice
3	Architectural Constraint Enforcement	Layer rules, forbidden patterns, naming conventions enforced at generation time — not at code review time.
7	Single Source of Truth	One canonical spec. Code, tests, and docs derive from it. Divergence is a build error, not a people problem.
8	Bounded Constitution	Every specification artifact fits within the AI's usable context window. No silent truncation. No blind spots.
10	TDD Phase Integrity	The RED phase cannot be bypassed. Structural gates enforce test-before-code at the commit level.
11	Ghost Failure Discrimination	Test failures tell you what the contract requires, not what the current implementation does.
13	Deterministic AI Output	Given the same spec and the same requirement, AI sessions converge on the same output. Reproducibility by design.
16	Architectural Decision Lineage	Every non-obvious decision has a recorded rationale. The AI cannot silently "correct" what it wasn't told was intentional.
17	Typed Change History	Every commit has type, scope, and intent. The git log is a machine-readable audit trail.
19	Living Documentation	Docs are derived from the spec — they update when the spec updates. They cannot drift.
20	Cross-Language Contract Consistency	Interface contracts hold across service boundaries regardless of implementation language.
23	Governed AI Surface	The AI's authority is bounded. What it may and may not do is written, not inferred.

Where is your team today?

30-second self-test

Check any that apply:

Two AI sessions on the same codebase produce structurally different output
A new engineer needs 30+ minutes of colleague context before they can start
Tests pass but the feature doesn't work the way you intended
An architectural decision from 3 months ago is invisible to new contributors
You've had a production incident caused by an implicit assumption between two systems
AI generates code that "looks right" but introduces coupling or layer violations you find later
When a senior developer leaves, the team loses the understanding of why the system is the way it is

3 or more

Multiple active pathologies. The audit names them.

1–2

Early stage — preventable before they compound.

Well-specified or very early project. Verify with the free audit.

The 25 pathologies GS prevents

Each is structurally prevented by one or more of the seven properties

Recognizing yours is the first step to resolving them.

🔴 Critical — active structural damage

#	Pathology	What you observe
1	Architectural Drift	AI output structurally incoherent across sessions. Each session locally valid; system diverges over time.
2	Specification Absence	No derivable spec. Every new session reconstructs intent from code — incorrectly and differently each time.
3	Implicit Architecture	Architectural rules live in heads, not artifacts. AI violates boundaries it was never told about.
4	Implicit Contract Syndrome	Two systems agree by assumption, not contract. The Mars Climate Orbiter failure mode. $327M demonstrated cost.
5	AI Security Blindspot	No consequence classification. AI executes irreversible operations without a confirmation gate.
6	Session Amnesia	Context resets at every session boundary. Prior decisions and constraints evaporate.

🟠 High — compounding silently

#	Pathology	What you observe
7	Test Theater	Tests pass. Behavioral contracts aren't tested. Green CI on broken features.
8	ADR Debt	Decisions made and lost. Same decision relitigated in every session.
9	Scope Creep	Each AI session expands scope slightly. Boundaries never enforced.
10	Copilot Dependency	Only the AI knows what the code does. Humans can't audit output they can't follow.
11	Context Window Overflow	Sessions collapse under their own weight. Quality degrades; model attends to wrong signals.
12	Bus Factor	One person understands the system. AI or human departure = knowledge loss.
13	Naming Entropy	Inconsistent naming across sessions. AI invents synonyms. Search fails.
14	Commit Chaos	Commits untyped, oversized, untraceable. Git log useless as audit trail.
15	Documentation Decay	Docs written at project start. Code moved on. Docs actively mislead the AI.
16	Cascade Blindness	Spec change cascades downstream without anyone knowing. Tests pass on the old contract.
17	Layer Violation	AI adds to the nearest layer, not the right one. Domain logic in controllers.
18	Phantom Dependency	Components depend on each other in ways not declared. Refactoring breaks unexpected things.

🟡 Medium — detectable before critical

#	Pathology	What you observe
19	Onboarding Friction	New developers need weeks of handholding. New AI sessions need the same every time.
20	Prompt Engineering Dependency	Prompts are the spec. Change the model, lose the output.
21	Premature Optimization	AI optimizes for the nearest metric, not the system's actual constraints.
22	Over-Engineering	AI adds abstraction layers the spec never requested. Complexity compounds.
23	Tech Debt Invisibility	Debt known but untracked. Doesn't appear in audit trail. AI doesn't know it exists.
24	Compliance Gap	Regulatory requirements exist in someone's head. The AI never had them.
25	Tooling Mismatch	AI uses the wrong tool. Not because it's wrong — because the spec never said which tool to use when.

How the seven properties map to both

Each property prevents pathologies and builds capabilities

GS Property	Pathologies it prevents	Capabilities it builds
Self-describing	Architectural Drift, Session Amnesia, Implicit Architecture, Onboarding Friction, ADR Debt	Cross-Session Coherence, Stateless Derivability, Derivable Project Knowledge
Bounded	Context Window Overflow, Scope Creep, Layer Violation, Tooling Mismatch	Bounded Constitution, Architectural Constraint Enforcement
Verifiable	Test Theater, Cascade Blindness, Compliance Gap	Behavioral Verification, Specification-Bound Verification
Defended	AI Security Blindspot, Cascade Blindness, Premature Optimization	Spec-Level Security, TDD Phase Integrity, Governed AI Surface
Auditable	ADR Debt, Commit Chaos, Documentation Decay, Tech Debt Invisibility	Architectural Decision Lineage, Typed Change History, Living Documentation
Composable	Phantom Dependency, Layer Violation, Over-Engineering	Cross-Language Contract Consistency, Single Source of Truth
Executable	Test Theater, Compliance Gap, Tooling Mismatch	Ghost Failure Discrimination, Deterministic AI Output

Seven properties and the SAVED report card published in the GS White Paper v4.0.

What to do next

Three paths forward

Free · Immediate

Run the codebase audit

Any repo. Produces a SAVED report card — a letter grade per property — with named pathologies and a remediation priority list. Free for individuals.

pragmaworks.dev/audit

Workshop · $20,000 · up to 15

La Fragua

Sixteen hours of hands-on work (four mornings remote, or two days on site) delivering the seven properties operationally, on your own code. Teams leave with a working spec, sentinel and harness on a real project, and the recipes to enforce their top pathologies.

Learn about La Fragua →

Remediation · from $20,000

Done-for-you remediation

Done-for-you remediation, scoped from the Readiness Assessment. Start with a free discovery call.

Book a 30-min call →