OpenParable
Skip to content
← Back to skills

Dapp Sdd:plan

Productivity
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.

View on GitHub ↗
QUICK START

How to use this skill

Bring this guide into your coding agent with a prompt tailored to the tool you use.

  1. Open your project in Codex.
  2. Copy and paste the prompt below.
  3. Review files and risks before approving any action.
Prompt to paste
Inspect the Agent Skill at https://github.com/majiayu000/claude-skill-registry/blob/HEAD/skills/planning/plan-aaronbassett-midnight-knowledgeba/SKILL.md and all supporting files. Report provenance, permissions, scripts, dependencies, and security risks. Propose an exact installation into .agents/skills/dapp-sdd-plan, but wait for my approval before writing files or running scripts.

Copying this prompt does not install or run the skill. Review third-party files before use.

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

# {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