design-discovery-full — Claude Code rule
The design-discovery-full rule systematically maps requirements, existing code, technologies, and risks before design begins. It ensures architectural choices rest on facts rather than assumptions.
MIT ★ 3,774 updated 2026-10-22
.claude/rules/design-discovery-full.mdWhat design-discovery-full does
The rule structures pre-design work into six stages: extract functional and non-functional requirements, analyze the current codebase for reusable components and integration points, investigate technologies and best practices via web search and documentation, verify external dependencies for API contracts and compatibility, evaluate architectural patterns against your constraints, and assess technical risks. At each stage it searches for current sources—official docs, recent articles, Stack Overflow—and fetches them to verify API signatures, version compatibility, rate limits, and security considerations.
Findings flow into research.md: key insights shaping architecture, discovered constraints, chosen approaches with reasoning, rejected alternatives and trade-offs, domain boundaries, risks, and gaps requiring deeper work. The rule gives clear triggers for when to always search (APIs, security, versions), when to search if uncertain (patterns, standards, scale), and how to begin (official sources first, then blogs and community).
It works as a precursor to design work—run it before asking for architecture or integration proposals. Pairs well with a design rule that then builds on research.md to make concrete decisions.
What it helps with
- map all requirements and technical constraints into a single checklist
- select an architecture pattern grounded in practice and docs, not guesswork
- verify external dependency APIs, versions and limits before writing code
- document risks and rejected approaches so teams don't revisit them
- audit the existing codebase to find extension points and integration seams
Example prompts for the agent
- Run full discovery on a new payment module: requirements, provider research, risk assessment
- Research architecture changes before refactoring the database abstraction layer; capture findings in research.md
- Find best practices for scaling WebSocket connections and check compatibility with our current stack
How to install design-discovery-full
Manually: put the files in place
.claude/rules/design-discovery-full.mdThe paths frontmatter field limits the files
AGENTS.md
Codex reads AGENTS.md: paste the rule text there
Manually: put the files in place
.cursor/rules/design-discovery-full.mdcFrontmatter: description, globs, alwaysApply
Manually: put the files in place
.github/instructions/design-discovery-full.instructions.mdThe applyTo field sets which files it applies to
Manually: put the files in place
.devin/rules/design-discovery-full.mdManually: put the files in place
.clinerules/design-discovery-full.mdStep by step, with commands for each platform: AGENTS.md vs CLAUDE.md: what they are and which one to use
Questions about design-discovery-full
How do I install design-discovery-full in Claude Code?
Copy the rule file to your project's .claude/rules/ folder—create the directory if it does not exist—and save it as design-discovery-full.md. Claude Code will load it automatically on the next interaction.
What does design-discovery-full do?
It is a checklist for research before design: requirements, codebase analysis, technology investigation, dependency verification, architecture evaluation, and risk assessment. Findings go into research.md, creating a shared reference for design decisions.
Why use this rule instead of just asking the AI to design?
The AI can propose a design without knowing your existing architecture, constraints, or domain practices. This rule enforces research first—so the architecture rests on your facts, not general patterns.
Source text
design-discovery-full.md · MIT
# Full Discovery Process for Technical Design ## Objective Conduct comprehensive research and analysis to ensure the technical design is based on complete, accurate, and up-to-date information. ## Discovery Steps ### 1. Requirements Analysis **Map Requirements to Technical Needs** - Extract all functional requirements from EARS format - Identify non-functional requirements (performance, security, scalability) - Determine technical constraints and dependencies - List core technical challenges ### 2. Existing Implementation Analysis **Understand Current System** (if modifying/extending): - Analyze codebase structure and architecture patterns - Map reusable components, services, utilities - Identify domain boundaries and data flows - Document integration points and dependencies - Determine approach: extend vs refactor vs wrap ### 3. Technology Research **Investigate Best Practices and Solutions**: - **Use WebSearch** to find: - Latest architectural patterns for similar problems - Industry best practices for the technology stack - Recent updates or changes in relevant technologies - Common pitfalls and solutions - **Use WebFetch** to analyze: - Official documentation for frameworks/libraries - API references and usage examples - Migration guides and breaking changes - Performance benchmarks and comparisons ### 4. External Dependencies Investigation **For Each External Service/Library**: - Search for official documentation and GitHub repositories - Verify API signatures and authentication methods - Check version compatibility with existing stack - Investigate rate limits and usage constraints - Find community resources and known issues - Document security considerations - Note any gaps requiring implementation investigation ### 5. Architecture Pattern & Boundary Analysis **Evaluate Architectural Options**: - Compare relevant patterns (MVC, Clean, Hexagonal, Event-driven) - Assess fit with existing architecture and steering principles - Identify domain boundaries and ownership seams required to avoid team conflicts - Consider scalability implications and operational concerns - Evaluate maintainability and team expertise - Document preferred pattern and rejected alternatives in `research.md` ### 6. Risk Assessment **Identify Technical Risks**: - Performance bottlenecks and scaling limits - Security vulnerabilities and attack vectors - Integration complexity and coupling - Technical debt creation vs resolution - Knowledge gaps and training needs ## Research Guidelines ### When to Search **Always search for**: - External API documentation and updates - Security best practices for authentication/authorization - Performance optimization techniques for identified bottlenecks - Latest versions and migration paths for dependencies **Search if uncertain about**: - Architectural patterns for specific use cases - Industry standards for data formats/protocols - Compliance requirements (GDPR, HIPAA, etc.) - Scalability approaches for expected load ### Search Strategy 1. Start with official sources (documentation, GitHub) 2. Check recent blog posts and articles (last 6 months) 3. Review Stack Overflow for common issues 4. Investigate similar open-source implementations ## Output Requirements Capture all findings that impact design decisions in `research.md` using the shared template: - Key insights affecting architecture, technology alignment, and contracts - Constraints discovered during research - Recommended approaches and selected architecture pattern with rationale - Rejected alternatives and trade-offs (documented in the Design Decisions section) - Updated domain boundaries that inform Components & Interface Contracts - Risks and mitigation strategies - Gaps requiring further investigation during implementation
© gotalab · MIT · gotalab/cc-sdd