# Dapp Sdd:plan

> Dapp Sdd:plan is an Agent Skill for productivity published in the majiayu000/claude-skill-registry repository on GitHub: a SKILL.md instruction file an AI agent can load to do this task.

Use when creating a phased implementation plan from a specification, with review gates after each phase.

- Skill name: `dapp-sdd:plan`
- Category: [Productivity](https://www.openparable.com/skill/productivity/1)
- Source: https://github.com/majiayu000/claude-skill-registry/blob/HEAD/skills/planning/plan-aaronbassett-midnight-knowledgeba/SKILL.md
- Repository: majiayu000/claude-skill-registry (498 GitHub stars when collected)

## SKILL.md

# Plan Skill

Creates a phased implementation plan with mandatory review gates.

## Input

- `.dapp-sdd/spec.md` - The expanded specification
- `dapp-sdd:constitution` - Quality standards to follow

## Output

A phased plan saved to `.dapp-sdd/plan.md` with:
- Clear phases (small, focused chunks)
- Review gates after each phase
- Skill references for each task

## Phase Structure

Every plan follows this structure:

### Phase 1: Project Setup
- Verify `create-mn-app` scaffold
- Set up linting/formatting
- Configure TypeScript strict mode
- Add `.dapp-sdd/` to `.gitignore`
- **REVIEW GATE**

### Phase 2: Contract Implementation
- Create contract skeleton
- Implement core circuits
- Add state management
- **REVIEW GATE**

### Phase 3: TypeScript Integration
- Create deployment script
- Create CLI interface
- Add provider configuration
- **REVIEW GATE**

### Phase 4: Testing
- Write contract unit tests
- Write integration tests
- Verify all tests pass
- **REVIEW GATE**

### Phase 5: Documentation & Polish
- Update README with final documentation
- Add educational comments
- Clean up code
- **FINAL REVIEW GATE**

## Plan Format

```markdown
# {DApp Name} Implementation Plan

## Phase 1: Project Setup

**Goal:** Establish project foundation with quality tooling

### Tasks
1. Verify create-mn-app scaffold is complete
2. Configure ESLint with strict rules
3. Configure Prettier for formatting
4. Verify TypeScript strict mode
5. Add `.dapp-sdd/` to `.gitignore`

**Skills:** `midnight-tooling:midnight-setup`

### Review Gate
- [ ] `compact-reviewer:compact-reviewer` (if contracts exist)
- [ ] `devs:code-reviewer`

---

## Phase 2: Contract Implementation

**Goal:** Implement the Compact smart contract

### Tasks
1. Create contract skeleton in `contracts/{name}.compact`
2. Define ledger state
3. Implement circuit: `{circuit_name}`
4. Add witness functions

**Skills:** `compact-core:language-reference`, `compact-core:contract-patterns`, `compact-core:standard-library`

### Review Gate
- [ ] `compact-reviewer:compact-reviewer`
- [ ] `devs:code-reviewer`

---

(Continue for remaining phases...)
```

## Process

1. Load specification from `.dapp-sdd/spec.md`
2. Load constitution from `dapp-sdd:constitution`
3. Analyze user stories to determine complexity
4. Create appropriate number of phases (typically 4-5)
5. Assign tasks to phases based on dependencies
6. Add review gates after each phase
7. Reference appropriate skills for each phase
8. Save to `.dapp-sdd/plan.md`

## Skill References

Reference these skills in the plan:
- `compact-core:contract-patterns` - Contract design patterns
- `compact-core:typescript-integration` - TS integration patterns
- `midnight-proofs:*` - Proof generation approach
- `midnight-tooling:midnight-setup` - Tooling configuration

---

Source: https://www.openparable.com/skill/productivity/dapp-sdd-plan (OpenParable). Cite the canonical URL above.
