# Dapp Sdd:plan

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

- Skill: `majiayu000/dapp-sdd-plan` (Agent Skill, multi-file: 2 files)
- Install (CLI): `npx skillmds add majiayu000/dapp-sdd-plan`
- Raw SKILL.md: https://api.skillmd.com/api/skills/majiayu000/dapp-sdd-plan/raw
- Safety review: pending
- Works with: Claude Code, Claude.ai, OpenAI Codex
- Category: Coding & Dev Tools
- Author: majiayu000 (https://skillmd.com/u/majiayu000)
- Updated: 2026-09-09
- Page: https://skillmd.com/skills/majiayu000/dapp-sdd-plan

---


# 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