CHECKLIST

The following checklists support the SDD extension for superhuman code quality.

Phase SDD-1: Constitution Definition Checklist

Use when establishing unbreakable rules for a project.

Tech Stack Constitution

• Not done: Languages specified with exact versions?
• Not done: Frameworks specified with exact versions?
• Not done: Database and infrastructure choices documented?
• Not done: Required libraries listed with versions?
• Not done: Forbidden libraries listed with reasons?

Directory Structure Constitution

• Not done: Top-level directory structure documented?
• Not done: File naming conventions specified?
• Not done: Component organization patterns defined?
• Not done: Test file locations standardized?
• Not done: Configuration file locations fixed?

Coding Standards Constitution

• Not done: Naming conventions defined (files, variables, functions, classes)?
• Not done: Error handling patterns specified?
• Not done: Logging standards documented?
• Not done: Import ordering rules set?
• Not done: Comment/documentation requirements established?

Anti-Patterns Constitution

• Not done: Forbidden patterns listed with reasons?
• Not done: Security anti-patterns explicitly prohibited?
• Not done: Performance anti-patterns documented?
• Not done: Architectural anti-patterns named?
• Not done: Each anti-pattern has detection method?

Security Constitution

• Not done: Authentication requirements specified?
• Not done: Authorization model defined?
• Not done: Input validation requirements documented?
• Not done: Encryption standards set (at-rest, in-transit)?
• Not done: Secret management rules established?

Performance Constitution

• Not done: Latency budgets defined (p50, p95, p99)?
• Not done: Memory limits specified?
• Not done: Bundle size budgets set?
• Not done: Database query limits documented?
• Not done: API rate limits established?

Testing Constitution

• Not done: Coverage minimums set (unit, integration, e2e)?
• Not done: Test naming conventions defined?
• Not done: Mock/stub policies established?
• Not done: CI/CD gate criteria specified?
• Not done: Test data management rules set?

Exit criteria: Every rule in the constitution is machine-enforceable or has explicit human review point.

Phase SDD-2: Blueprint Creation Checklist

Use when creating specifications before implementation.

Functional Specification

• Not done: All user stories written in standard format?
• Not done: Every story has acceptance criteria?
• Not done: Requirements have unique IDs (REQ-DOMAIN-###)?
• Not done: Edge cases documented for each requirement?
• Not done: Error states explicitly defined?
• Not done: Non-functional requirements have metrics?

Technical Specification

• Not done: Architecture diagram created?
• Not done: Data models have exact field types and constraints?
• Not done: API contracts fully defined (request/response schemas)?
• Not done: Component contracts have exact method signatures?
• Not done: Error handling documented per component?
• Not done: Performance budgets assigned per component?

Task Specification

• Not done: Tasks are atomic (one conceptual change)?
• Not done: Each task has input_context_files list?
• Not done: Each task has definition_of_done with signatures?
• Not done: Task dependencies form valid DAG (no cycles)?
• Not done: Layer ordering enforced (foundation → logic → surface)?
• Not done: Each task has verification commands?

Traceability Matrix

• Not done: Every requirement has corresponding task(s)?
• Not done: Every task traces to requirement(s)?
• Not done: No requirements have empty “Covered by Task” column?
• Not done: Test cases link to requirements they validate?
• Not done: Traceability matrix passes automated checks?

Blueprint Completeness

• Not done: Intent documents exist for major features?
• Not done: All acceptance criteria are testable?
• Not done: No ambiguous language (“fast”, “secure”, “simple”)?
• Not done: All domain terms defined in glossary?
• Not done: Examples provided for complex requirements?

Exit criteria: Traceability matrix shows 100% coverage from requirements to tasks.

Phase SDD-3: Superhuman Output Verification Checklist

Use when verifying AI-generated code meets superhuman standards.

Namespace Perfection

• Not done: Zero naming collisions across codebase?
• Not done: Naming conventions followed 100%?
• Not done: No magic strings or numbers?
• Not done: Constants extracted and properly named?
• Not done: No duplicate function/variable names in scope?

Test Coverage

• Not done: 100% line coverage achieved?
• Not done: 100% branch coverage achieved?
• Not done: All edge cases have tests?
• Not done: All error paths have tests?
• Not done: Tests are deterministic (no flaky tests)?

Structural Rigidity

• Not done: File structure matches constitution exactly?
• Not done: Function lengths within limits?
• Not done: Cyclomatic complexity within limits?
• Not done: Dependency direction enforced (no circular imports)?
• Not done: Layer boundaries respected?

Traceability Completeness

• Not done: Every function has requirement reference in comments?
• Not done: Every test has requirement reference?
• Not done: Traceability matrix updated with code locations?
• Not done: No orphan code (code without requirement trace)?
• Not done: No orphan requirements (requirements without code)?

Documentation Completeness

• Not done: Every public function documented?
• Not done: Every public type/interface documented?
• Not done: Every API endpoint documented?
• Not done: All parameters and return values described?
• Not done: Examples included for complex APIs?

Error Handling Completeness

• Not done: Every external call has error handling?
• Not done: Every async operation has error handling?
• Not done: All error messages are user-friendly?
• Not done: All errors are logged with context?
• Not done: Recovery paths exist for recoverable errors?

Constitution Compliance

• Not done: Linting passes with zero warnings?
• Not done: Type checking passes with zero errors?
• Not done: Security scanning passes?
• Not done: Performance budgets met?
• Not done: All anti-patterns avoided?

Exit criteria: Code quality is impossible to achieve manually. Deviations are immediately visible.

Phase 0: Loyalty Audit

Use BEFORE any other checklist. This is the foundation.

Architectural Commitment Inventory

• Not done: What architectural decisions have we committed to?
• Not done: What patterns have we chosen and must maintain?
• Not done: What API contracts exist that we must honor?
• Not done: What deprecation timelines have we promised?

The Betrayal Test

For any proposed change:

• Not done: Does this honor or break our existing commitments?
• Not done: Are we improving within constraints, or abandoning ship?
• Not done: Would we feel ashamed explaining this change to someone who trusted our previous commitment?
• Not done: Is this “optimization” or “betrayal”?

The Shiny Object Test

• Not done: Is this change driven by genuine need or trend-chasing?
• Not done: Would we consider this if it weren’t currently popular?
• Not done: Are we solving OUR problem or copying someone else’s solution?
• Not done: Have we given our current approach enough time/effort?

Loyalty-Preserving Alternatives

• Not done: Can we achieve the goal while honoring existing commitments?
• Not done: Is there a way to evolve rather than replace?
• Not done: What’s the minimum viable change that doesn’t betray?

When Betrayal Is Justified

(These are rare. Be honest.)

• Not done: The original commitment was made with incorrect information
• Not done: External circumstances have fundamentally changed
• Not done: Continuing would cause genuine harm
• Not done: We’ve communicated the change to affected parties
• Not done: We accept the trust cost

Exit criteria: I can honestly say I’m improving, not betraying.

Phase 1: Domain Discovery Checklist

Use before ANY technical discussion.

Problem Understanding

• Not done: Can I explain the problem in domain terms, not technical terms?
• Not done: Do I know who the actual users are?
• Not done: Do I understand what “success” looks like to users?
• Not done: Have I identified domain-specific vocabulary?

Domain Complexity

• Not done: What are the edge cases in this domain?
• Not done: What happens when the “happy path” doesn’t apply?
• Not done: What domain rules seem simple but have hidden complexity?
• Not done: What domain knowledge am I missing?

Stakeholder Understanding

• Not done: Who cares if this works?
• Not done: Who cares if this fails?
• Not done: Who has domain expertise I should consult?
• Not done: What competing interests exist between stakeholders?

Domain Constraints

• Not done: What regulatory requirements apply?
• Not done: What industry standards must be followed?
• Not done: What domain-specific compliance exists?
• Not done: What domain assumptions should I challenge?

Exit criteria: I can explain the problem to a domain expert and they would nod, not correct me.

Phase 2: Systems Thinking Checklist

Use when mapping dependencies and failure modes.

Dependency Mapping

• Not done: What internal systems does this depend on?
• Not done: What external systems does this depend on?
• Not done: What depends on THIS system?
• Not done: Have I drawn the dependency diagram?

External Dependency Audit

For each external dependency:

• Not done: What version are we using?
• Not done: When was it last updated?
• Not done: What’s their breaking change policy?
• Not done: Do we have monitoring for their failures?
• Not done: What’s our fallback if they disappear?

Failure Mode Analysis

• Not done: What happens when [component A] fails?
• Not done: What happens when [external API] is slow?
• Not done: What happens when [database] is unavailable?
• Not done: What cascading failures are possible?
• Not done: What silent failures are possible?

Monitoring & Alerting

• Not done: How do we know if this is working?
• Not done: How do we know if this is broken?
• Not done: Who gets alerted when it fails?
• Not done: What’s the time-to-detection?
• Not done: What’s the time-to-recovery?

Scale Considerations

• Not done: What’s the current scale?
• Not done: What scale do we need in 12 months?
• Not done: What breaks at 10x scale?
• Not done: What breaks at 100x scale?

Exit criteria: I can trace any failure to its impact and know who gets paged.

Phase 3: Constraint Mapping Checklist

Use before proposing solutions.

Technical Constraints

• Not done: What existing systems can’t be changed?
• Not done: What data formats are locked in?
• Not done: What APIs must we maintain?
• Not done: What performance requirements exist?
• Not done: What security requirements exist?

Organizational Constraints

• Not done: Which teams own which components?
• Not done: What approval chains exist?
• Not done: Who has authority to approve this?
• Not done: Who has context but not authority?
• Not done: Who has authority but not context?

Business Constraints

• Not done: What’s the budget?
• Not done: What’s the timeline?
• Not done: What compliance requirements apply?
• Not done: What contracts constrain us?
• Not done: What vendor relationships affect this?

Political Constraints

(These exist. Ignoring them causes failed projects.)

• Not done: Whose system would this change affect?
• Not done: Who built the current system? Are they still here?
• Not done: Which teams have historically resisted changes?
• Not done: What past decisions are politically sensitive?
• Not done: Who needs to be consulted even if not required?

The Shippability Test

• Not done: Can this actually ship given our constraints?
• Not done: What would prevent this from shipping?
• Not done: Who could block this and why?
• Not done: What’s the minimum viable version that ships?

Exit criteria: I know what’s fixed vs. flexible and what could block shipping.

Phase 4: AI Decomposition Checklist

Use when breaking work into AI-solvable chunks.

Task Boundary Quality

For each AI task:

• Not done: Is the input clearly defined?
• Not done: Is the expected output clearly defined?
• Not done: Can success be objectively verified?
• Not done: Does the task have bounded scope?

Context Completeness

For each AI task:

• Not done: Does the AI have all needed information?
• Not done: Are there hidden assumptions the AI would need to know?
• Not done: Is the context self-contained?
• Not done: Can the task be understood without external knowledge?

Failure Handling

For each AI task:

• Not done: What happens if this task fails?
• Not done: Can we retry safely?
• Not done: Does failure cascade to other tasks?
• Not done: Is there a fallback strategy?

Independence Assessment

• Not done: Can tasks run in parallel?
• Not done: What sequential dependencies exist?
• Not done: What shared state would cause conflicts?
• Not done: What’s the critical path?

Verification Points

• Not done: Where do humans verify AI output?
• Not done: What verification criteria exist?
• Not done: How long does verification take?
• Not done: What happens if verification fails?

Composition Planning

• Not done: How do AI outputs integrate?
• Not done: What gaps exist between tasks?
• Not done: Who handles the integration?
• Not done: How do we ensure overall coherence?

Exit criteria: Each task has clear boundaries, and I know how to verify and compose results.

Phase 5: AI-First Development Checklist

Use when evaluating modern tools, edge AI, agentic patterns, and self-learning capabilities.

Technology Discovery

• Not done: Could Rust/WASM improve performance for critical paths?
• Not done: Would claude-flow simplify multi-agent orchestration?
• Not done: Does this need persistent memory (agentdb)?
• Not done: Would vector search/RAG enhance the experience?
• Not done: Have I evaluated alternatives to proposed tools?

Edge AI Evaluation

• Not done: Could edge LLMs reduce latency or API costs?
• Not done: What features should work offline?
• Not done: Is there sensitive data that should stay on-device?
• Not done: Would hybrid local/cloud architecture work?
• Not done: What models fit the device constraints (Phi-3, Gemma, TinyLlama)?
• Not done: Is in-browser inference viable (WebLLM, Transformers.js)?

Agentic Patterns

• Not done: Is this a candidate for agentic workflow vs. request-response?
• Not done: Would Claude Agent SDK help build reusable agents?
• Not done: What MCP integrations would enhance this?
• Not done: Should agents run in parallel or sequentially?
• Not done: How do agents communicate shared state?

Self-Learning Capabilities

• Not done: Could feedback loops improve accuracy over time?
• Not done: What user corrections could train the system?
• Not done: Where can we capture implicit signals (edits, time, acceptance)?
• Not done: Would A/B experimentation help optimize behavior?
• Not done: Can we fine-tune on domain-specific usage?
• Not done: How do we measure if learning is working?

User-Facing Skills

• Not done: Would end users benefit from skills that enhance AI outputs?
• Not done: What interpretation skills help users understand responses?
• Not done: What action skills turn suggestions into next steps?
• Not done: Should we provide domain-specific skills (/legal-review, /code-refactor)?
• Not done: What transformation skills convert outputs to useful formats?

Project Documentation

• Not done: Should we create a project-specific SKILLS.md?
• Not done: What domain vocabulary needs documenting for AI context?
• Not done: What architectural decisions should persist across sessions?
• Not done: How do we ensure consistent behavior?

Continuous Verification

• Not done: What automated tests verify each feature?
• Not done: Are pre-commit hooks running affected tests?
• Not done: Is watch mode enabled during development?
• Not done: What’s the rollback strategy if tests fail post-deploy?
• Not done: Are integration tests covering API contracts?
• Not done: Is visual regression testing needed for UI?

Exit criteria: I’ve evaluated modern tools, decided what benefits the project, and planned for automated verification.

Phase 6: Solution Validation Checklist

Use before finalizing recommendations.

Domain Fit

• Not done: Does this actually solve the domain problem?
• Not done: Would a domain expert agree this solves their problem?
• Not done: Have I validated with stakeholders?
• Not done: Does the solution match user needs?

Systems Fit

• Not done: Does this work with existing dependencies?
• Not done: Have I addressed failure modes?
• Not done: Is monitoring and alerting planned?
• Not done: Does this fit within scale requirements?

Constraint Fit

• Not done: Does this fit technical constraints?
• Not done: Does this fit organizational constraints?
• Not done: Does this fit budget and timeline?
• Not done: Can this actually ship?

Tradeoff Transparency

• Not done: Have I made tradeoffs explicit?
• Not done: Do stakeholders understand what we’re giving up?
• Not done: Are there options with different tradeoff profiles?
• Not done: Is the recommended tradeoff justified?

Implementation Readiness

• Not done: Is the approach detailed enough to implement?
• Not done: Are AI task boundaries defined?
• Not done: Are verification points established?
• Not done: Is the critical path identified?

Exit criteria: Solution addresses domain needs, fits constraints, and can ship.

Quick Pre-Meeting Checklist

Before architectural discussions:

Before I propose anything:

• Not done: Have I asked about the domain?
• Not done: Have I mapped dependencies?
• Not done: Have I asked about constraints?
• Not done: Do I know what can’t change?

Before I agree to anything:

• Not done: Can this actually ship?
• Not done: Who needs to approve?
• Not done: What’s the timeline?
• Not done: What could block this?

Before I decompose for AI:

• Not done: Are tasks bounded?
• Not done: Can outputs be verified?
• Not done: Where do humans checkpoint?
• Not done: How do pieces integrate?

Before I choose tools/patterns:

• Not done: Have I evaluated edge AI options?
• Not done: Would agentic workflows simplify this?
• Not done: Could self-learning benefit users?
• Not done: Is automated testing planned?

Red Flags Checklist

Warning signs that architectural thinking is missing:

Domain Red Flags

• Not done: Solution discussed before problem understood
• Not done: Technical terms used, domain terms missing
• Not done: “Users” mentioned generically without specifics
• Not done: Edge cases dismissed as “rare”

Systems Red Flags

• Not done: No dependency diagram exists
• Not done: External APIs treated as always available
• Not done: “We’ll add monitoring later”
• Not done: Single points of failure not identified

Constraint Red Flags

• Not done: “In an ideal world…” framing
• Not done: Legacy systems dismissed as “bad”
• Not done: Political constraints ignored
• Not done: Budget/timeline not discussed

AI Decomposition Red Flags

• Not done: “AI can just figure it out”
• Not done: Tasks like “make it better”
• Not done: No verification points planned
• Not done: Integration assumed to be easy

AI-First Development Red Flags

• Not done: Adding tools without evaluating simpler alternatives
• Not done: “We need AI” without clear use case
• Not done: Edge AI dismissed without latency/cost analysis
• Not done: No automated testing planned for AI features
• Not done: Self-learning assumed without feedback mechanism
• Not done: User-facing skills not considered for complex outputs
• Not done: No rollback strategy for AI failures

If any red flags are checked: Stop and address before proceeding.

Post-Mortem Checklist

After failures or surprises:

What broke?

• Not done: What was the direct cause?
• Not done: What was the root cause?
• Not done: Was this a known failure mode?
• Not done: Was monitoring in place?

Why didn’t we see it coming?

• Not done: Did we miss a dependency?
• Not done: Did we miss a constraint?
• Not done: Did we ignore a warning sign?
• Not done: Did external factors change?

Domain Learning

• Not done: What domain knowledge were we missing?
• Not done: Who should we have consulted?
• Not done: What assumption was wrong?

Systems Learning

• Not done: What dependency failed?
• Not done: What cascade occurred?
• Not done: What monitoring was missing?

Process Improvement

• Not done: What checklist item would have caught this?
• Not done: What question should we have asked?
• Not done: What constraint did we miss?
• Not done: How do we prevent this class of failure?