home / skills / madebyaris / spec-kit-command-cursor / sdd-research

sdd-research skill

safe

/.cursor/skills/sdd-research

This skill performs focused research on codebase patterns and external solutions to inform specification and planning.

npx playbooks add skill madebyaris/spec-kit-command-cursor --skill sdd-research

Review the files below or copy the command above to add this skill to your agents.

Files (2)

SKILL.md

2.4 KB

---
name: sdd-research
description: Pattern investigation and technical research before specification. Use when technical approach is unclear, exploring existing solutions, or analyzing codebase patterns.
---

# SDD Research Skill

Investigate codebase patterns and external solutions to inform specification and planning.

## When to Use

- Technical approach is unclear
- Need to understand existing patterns
- Evaluating solution options
- Before `/specify` or `/plan` commands
- When `sdd-explorer` findings need deeper analysis

## Research Protocol

### Phase 1: Codebase Analysis
1. **Existing patterns**: How similar problems are solved
2. **Reusable components**: What can be leveraged
3. **Conventions**: Naming, structure, architecture patterns
4. **Dependencies**: What libraries/frameworks are used

### Phase 2: External Solutions
1. **Best practices**: Industry standards for this problem
2. **Library options**: Available tools and their tradeoffs
3. **Architecture patterns**: Applicable design patterns
4. **Reference implementations**: Similar solutions elsewhere

### Phase 3: Synthesis
1. **Compare options**: Pros/cons matrix
2. **Recommend approach**: Based on findings
3. **Flag risks**: Technical concerns and unknowns
4. **Document assumptions**: What needs validation

## Research Output Format

```markdown
# Research: [Topic]

## Summary
[1-2 sentence overview of findings]

## Codebase Analysis

### Existing Patterns
| Pattern | Location | Relevance |
|---------|----------|-----------|
| [pattern] | [file/dir] | [how it applies] |

### Reusable Components
- [component]: [how to leverage]

### Conventions
- [convention type]: [standard used]

## External Solutions

### Option 1: [Name]
- **Pros**: [advantages]
- **Cons**: [disadvantages]
- **Effort**: [estimate]

### Option 2: [Name]
- **Pros**: [advantages]
- **Cons**: [disadvantages]
- **Effort**: [estimate]

## Comparison Matrix

| Criteria | Option 1 | Option 2 |
|----------|----------|----------|
| [criteria] | [score] | [score] |

## Recommendation
[Recommended approach with rationale]

## Risks & Unknowns
- [risk]: [mitigation]

## Next Steps
1. [action item]
```

## Reference Patterns

See `references/patterns.md` for common architectural patterns and when to use them.

## Integration

- Findings feed into `/specify` command
- Informs `sdd-planner` subagent decisions
- Can be invoked by `sdd-explorer` for deeper analysis
- Use the ask question tool when research reveals multiple valid approaches

Overview

This skill investigates codebase patterns and external solutions to inform specification and planning. It performs targeted technical research when the implementation approach is unclear, producing a concise recommendation, risk analysis, and next steps that feed into the SDD workflow.

How this skill works

The skill inspects the repository for existing patterns, reusable components, conventions, and dependencies. It surveys external libraries, architectures, and reference implementations, then synthesizes findings into a pros/cons comparison, recommended approach, and a short action plan.

When to use it

When the technical approach for a feature is unclear or has multiple viable options
Before running /specify or /plan to ensure proposals align with codebase patterns
To evaluate and compare third-party libraries or frameworks
When sdd-explorer surfaces patterns that need deeper validation
If you need a concise risk and assumptions list before committing to a design

Best practices

Start with a focused research question and scope the code paths to inspect
Prioritize reusing existing components and following established conventions
Document tradeoffs numerically or in a simple pros/cons matrix
Flag uncertainties explicitly and propose small validation tasks
Keep outputs concise and action-oriented so they plug into /specify and /plan

Example use cases

Choosing between two authentication libraries and estimating integration effort
Determining whether a shared component can be extended or needs replacement
Evaluating performance implications of different data storage patterns
Reconciling conflicting naming and module structure conventions across the repo
Producing a short recommendation and risk list to feed into sdd-planner

FAQ

What output will I get from this research?

A short research note with a summary, codebase analysis, external options, a comparison matrix, a recommended approach, risks, and next steps.

How deep is the codebase analysis?

Depth is scoped to the research question: it inspects relevant files, patterns, components, and dependencies rather than full-codebase audits.

Can this research be automated or does it need manual review?

The skill automates pattern discovery and option comparison but encourages manual validation for unresolved risks and assumptions.