Skip to main content
rule CX Codex

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

Install into Claude Code · Manually: put the files in place All methods and platforms ↓
.claude/rules/design-discovery-full.md
Open on GitHub

What 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.md

The paths frontmatter field limits the files

Step 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

Similar IDE rules

All IDE rules for Design →
gcp-architecture-discovery sstawski gcp-architecture-discovery — a skill that walks a GCP project outward from the service that broke and writes down what it finds: compute, networks, databases, buckets. The map stays on disk between sessions. CX Codex +1 ★ 151repo stars design-code-architecture wondelai design-code-architecture — a skill for Claude Code, Cursor, and other platforms that walks you through eight architecture phases — from boundaries and domain model through data choices to resilience. CX Codex +1 2,700installs ux-research-discovery-testing hueyexe ux-research-discovery-testing gives your agent a working method for discovery interviews, usability tests and synthesis, so product calls rest on observed behavior instead of opinions. CX Codex +1 545installs canvas-create-discovery Microsoft canvas-create-discovery — a subagent that scans Power Apps to map available controls, data sources, and APIs, then documents feasible design choices and constraints. Use it to validate your canvas app concept before implementation begins. CX Codex ★ 1,167repo stars discovery-process deanpeters discovery-process structures product discovery from an initial assumption to tested solutions so teams build features based on verified customer needs. CX Codex +1 3,400installs om-setup-discovery-pipeline open-mercato om-setup-discovery-pipeline adds the product layer on top of the delivery pipeline: roles, Definition of Ready, research directory. It runs when a repo needs to decide what to build and why before any ticket exists. CX Codex +1 2,400installs

From the same set12

The whole set →
tasks-parallel-analysis The tasks-parallel-analysis rule sets checks for marking tasks in tasks.md as parallel work. Use it when an agent drafts an implementation plan and needs to account for dependencies. CX Codex +1 ★ 3,774repo stars requirements-review-gate The requirements-review-gate rule halts work and requires fixing the requirements draft before requirements.md is written. It validates scope coverage, EARS format compliance, and structural quality. CX Codex +1 ★ 3,774repo stars design-review-gate design-review-gate audits draft architectures before generating design.md. It links requirement IDs to concrete components and prevents speculative interfaces. CX Codex +1 ★ 3,774repo stars ears-format The ears-format rule formats acceptance criteria with EARS patterns. Use it when a specification needs clear conditions, subjects, and system responses. CX Codex +1 ★ 3,774repo stars design-review design-review reviews technical design documents before coding starts and issues a GO/NO-GO verdict. Caps feedback at three critical issues tied directly to project requirements. CX Codex +1 ★ 3,774repo stars cc-sdd-new-agent The cc-sdd-new-agent skill guides a new coding-agent integration in cc-sdd, from official-format research and planning to implementation checks. CX Codex +1 ★ 3,774repo stars gap-analysis The gap-analysis rule structures the analysis of your existing codebase, identifies what's missing for a feature, and helps you decide whether to extend existing components or build new ones. CX Codex +1 ★ 3,774repo stars tasks-generation tasks-generation guides AI coding agents to generate structured, dependency-ordered technical task plans from specifications without leaking low-level code details. CX Codex +1 ★ 3,774repo stars

Project sponsors

Companies that keep this analytics open