Spec-Exact Development (SED) Manifesto

A comprehensive declaration of principles, philosophy, and practices
for AI-driven development without interpretation or assumption

Spec-Exact Development at a Glance

Tagline

"AI develops exactly as the spec defines — no interpretation, no assumption."

Background

A new development methodology created by Song Jaeho on November 4, 2025 to overcome the limitations of vibe coding.

Name

Spec-Exact Development (SED)
A paradigm where AI implements exactly what specifications define.

Problems with Prior Approaches

All modern AI development tools—Context, SpecKit, Skills, MCP, and others—are fundamentally the same: they all inject prompts to AI in identical ways, just with different names. This is the eternal nature of AI interaction.

The critical problem is not the tools themselves, but how AI interprets these prompts:

  • Specifications, context, and required skills are often described vaguely.
  • MCPs provide only fragmented pieces of information.
  • AI freely interprets requirements based on assumptions, creating unpredictable outcomes.
  • When AI produces incorrect results, developers enter a "hamster wheel" of iterative corrections.
  • This cycle repeats endlessly because AI has no choice but to interpret ambiguous instructions.
  • The fundamental flaw lies in the prompt itself, not the AI's capabilities.

SED's Solution

SED fundamentally solves the contradiction in how humans communicate with AI:

AI Evaluates Prompts

AI actively scores specifications and identifies gaps before execution.

Requests Improvements

AI can ask developers to enhance incomplete specifications rather than making assumptions.

Creates Better Specifications

Through this feedback loop, specifications become increasingly complete and precise.

Strict Execution Only

AI executes exactly what is specified—no interpretation, no improvisation, no assumptions.

Breaks the Hamster Wheel: By demanding complete specifications upfront, SED eliminates the cycle of guess-fix-repeat. The specification becomes the absolute standard that guarantees consistency. AI neither interprets nor infers—it executes only what is explicitly written.

1. Concept Definition

Spec-Exact Development (SED) is an AI-driven development paradigm in which the AI never deviates by even a single line from the specification.

  • The specification is the absolute standard.
  • AI neither interprets nor infers intent—it executes exactly what is written.
  • Therefore, specifications must be meticulously precise and complete.
  • In practice, the AI is given a complete architectural blueprint and reproduces it without deviation.

"If the spec is wrong, the product is wrong — by design."

The Root Problem SED Solves

Traditional AI development approaches—whether using Context files, SpecKits, Skills, or MCPs—all suffer from the same fundamental issue: they deliver prompts that AI must interpret. Regardless of the tool's name or format, the core problem remains unchanged. AI interprets these prompts freely, often incorrectly, leading developers into an endless cycle of corrections. This "hamster wheel" exists not because AI is flawed, but because the prompts themselves are inherently incomplete and ambiguous.

SED breaks this cycle by transforming the relationship between developers and AI. Instead of passively accepting vague prompts, AI actively evaluates them, assigns completeness scores, and requests improvements before execution. This collaborative validation process creates specifications of unprecedented clarity and completeness. Once validated, AI executes these specifications with absolute fidelity—no interpretation, no guesswork, only precise implementation.

What Must Be Specified

SED specifications are not limited to high-level concepts like file names, route names, or page names. They must include:

📦 Class Names and Function Names

Every class, function, and method must be explicitly named in the specification.

⚙️ Implementation Details

From simple calculations to complex algorithms and business logic, everything must be documented.

🗄️ Data Structures

Variable names, types, and data flow must be clearly defined.

🔀 Control Flow

Conditional logic, loops, and error handling paths must be specified.

💻 Complete Source Code

Specifications include fully implemented source code for logic, functions, and classes.

📝 Code Comments

Documentation comments, inline comments, and JSDoc/TSDoc annotations must be specified in advance.

🎨 CSS Styling

All styling information including colors, spacing, fonts, animations, and responsive breakpoints.

📱 User-Facing Text

Every text string displayed to users—labels, buttons, messages, tooltips, placeholders.

🌍 Internationalization (i18n)

Translation dictionaries for all supported languages, including locale-specific formats, pluralization rules, and right-to-left (RTL) support requirements.

The specification is a complete implementation blueprint that leaves no room for AI interpretation. By providing complete, executable code examples within the specification, we eliminate ambiguity and ensure the AI can follow the exact implementation pattern required. This includes not just functional code, but also comments, styling, user interface text, and translations—everything that comprises the final product.

Intellectual Property and Copyright

When development is conducted using publicly available SED specifications with AI assistance:

  • Copyright Ownership: The copyright of the resulting code belongs to the specification author, not to the AI.
  • Rationale: Since the AI strictly follows the specification without making creative decisions, the intellectual property derives from the specification itself.
  • Author Rights: The person who writes the specification is the creator of the work, regardless of who or what implements it.

This principle recognizes that in SED, the specification is the true creative work, and the implementation is merely its mechanical execution.

2. Fundamental Principles

2.1 Spec-Exactness Principle

  1. Development implements only what the specification defines.
  2. If the specification is incomplete, the AI must immediately return a Spec Error and stop development.

2.2 Spec Completeness Scoring

  1. Before development begins, the AI evaluates the specification and assigns a score from 0–100.
  2. Development may start only when the score is 90 or higher.
  3. The score evaluates:
    • Database design completeness
    • Clarity of business logic
    • Specificity of UI/UX requirements
    • Detail of the testing plan (unit/widget/e2e)
    • Definition of deployment and operational environments
Example: Insufficient spec score error
SpecError: Insufficient specification to execute.
Reason: Database schema, authentication flow, or encryption detail missing.
Required Spec Score: ≥90
Current Score: 42

2.3 Spec Is the Law

  1. AI never attempts to infer human intent.
  2. Ambiguous sentences in the specification are ignored and not implemented.
  3. Guessing is forbidden; only written instructions are executed.
  4. Specifications are absolute, but they may still contain mistakes.
    • Even if the specification is wrong, the AI must still follow it without inference.
    • When an error is suspected, the AI may request confirmation or revisions from a developer.
    • The AI may ask humans to update the spec but cannot modify the spec on its own.
  5. Ultimately, the AI must always follow the specification.

2.4 AI's Role in Spec Validation

While AI cannot directly modify specifications, it plays a crucial role in maintaining spec quality:

  1. Logic Verification: AI can analyze the specification logic for inconsistencies, contradictions, or potential issues.
  2. Testing and Validation: AI executes tests based on the specification and reports results to developers.
  3. Advisory Function: AI can recommend spec updates, suggest improvements, and identify areas requiring clarification.
  4. Feedback Loop: AI reports findings to developers, who then update the specification accordingly.

This creates a collaborative workflow where AI serves as both executor and quality assurance advisor, while developers maintain full control over specification content.

3. Development Process Phases

The AI analyzes the provided specification and assigns a score. In SED, the preparation phase requires a multi-dimensional blueprint so subsequent stages proceed smoothly.

For detailed specifications on storylines, database design, features, routing, functions, UI/UX requirements, testing, and deployment environments, please refer to the complete documentation at Development Workflow.

  • The AI implements precisely what the specification dictates—nothing more, nothing less.
  • Anything outside the specification is ignored.
  • If humans intervene, those adjustments must be captured as updated specifications.
  • In SED, "code changes" and "spec updates" are inseparable.

  • Verification runs autonomously based on the specification.
  • Test cases and expected outcomes are derived directly from the spec.
  • Every feature is evaluated solely by the question: "Does it match the specification?"
  • If verification fails, the AI returns appropriate error messages.

  • Human involvement is mandatory.
  • AI can generate deployment scripts, environment configs, and CI/CD procedures, but humans must review and execute the actual deployment commands.

  • The specification must cover operational automation, including logging, error reporting, and update scenarios.
  • During operations, AI monitors, reports, and recommends automated fixes.
  • When new requirements appear, follow the loop: update spec → re-evaluate score → redevelop.

4. Philosophy Summary

Category Content
Philosophy Spec is the truth. Development simply executes that truth.
AI's Role Makes no judgments—executes the specification without interpretation.
Developer's Role Devote energy to crafting complete, unambiguous specifications.
Quality Assurance Testing and verification are fully automated from the specification.
Deliverable Traits Consistent, verifiable, maintainable, and predictably high-quality.

5. Slogans and Core Messages

🧠

"AI does not imagine. It executes."

📜

"Spec is the contract. Spec is the code."

⚙️

"No assumption. No improvisation. Only implementation."

6. Prohibited Practices

SED strictly prohibits the following development approaches to maintain specification integrity:

6.1 Incremental Prompt-Based Modifications

❌ Prohibited:
  • Making iterative adjustments to AI output through progressive prompting
  • Asking AI to "fix this part" or "change that section" without updating the specification
  • Performing piecemeal modifications when the AI's implementation doesn't meet expectations
✅ Required Approach:
  1. When AI output is unsatisfactory, update the specification first
  2. Clearly document what needs to change and why in the spec
  3. Instruct AI to re-implement based on the updated specification
  4. Maintain full traceability between spec changes and code changes

Example of Prohibited Workflow:

Developer: "Make the button bigger"
Developer: "No, change the color to blue"
Developer: "Add a shadow effect"
Developer: "Move it to the right"

Example of Correct Workflow:

Developer: [Updates design spec]
  - Button: 48px height (increased from 40px)
  - Color: Primary blue (#6366F1)
  - Shadow: 0 2px 8px rgba(0,0,0,0.1)
  - Position: Right-aligned in container

Developer: "The specification has been updated. Please re-implement according to the new spec."

6.2 Design Modifications Without Spec Updates

❌ Prohibited:
  • Requesting design changes through ad-hoc prompts
  • Iteratively refining UI/UX by giving AI incremental feedback
  • Making visual adjustments without documenting them in the design specification
✅ Required Approach:
  1. Document all design requirements in the specification
  2. Include exact measurements, colors, spacing, typography, and behavior
  3. When design needs to change, update the design spec with precise details
  4. Have AI re-implement based on the updated design specification

Why This Matters:

  • Consistency: Every change is traceable and documented
  • Reproducibility: Anyone can recreate the exact implementation from specs
  • Maintainability: Future modifications have clear historical context
  • Quality Assurance: Specifications serve as the single source of truth

"In SED, there are no 'quick fixes' or 'small tweaks.' Every change starts with the specification."

7. SED's Core Challenge

SED demands precision and completeness, which naturally enlarges the specification—and therefore the token budget. To craft a truly complete specification, expect book-length documentation. Supplying that to an LLM consumes a significant number of tokens.

Proposed Solutions

  • Partition the entire spec into logical units (by module, feature, or layer).
  • Provide the LLM only with the relevant spec fragment for each stage.
  • Validate output at every stage before proceeding.
  • Design spec documents hierarchically.
  • Build reusable shared-spec libraries.

This approach preserves SED's philosophy while making it practical for real projects.

"Spec-Exact Development (SED) moves beyond prompt engineering. It establishes an AI-driven development philosophy centered on specification completeness, automated verification, and uncompromising consistency."

Ready to Practice SED?

Start creating complete, precise specifications and experience the power of Spec-Exact Development.

Get Started View Examples