skillZs
★ LIVE SKILL TAGS ★
>>> LIVE SKILLS INDEX <<<
* OPEN SOURCE *
NO LOGIN, NO TRACKING
※ REAL INSTALL DATA ※
← back to all skills
athola/claude-night-market249 installs

project-planning

Converts a specification into a phased, dependency-ordered implementation plan. Use after specification is complete and before execution begins.

How do I install this agent skill?

npx skills add https://github.com/athola/claude-night-market --skill project-planning
view source ↗

Is this agent skill safe to install?

  • Gen Agent Trust Hubpass

    The project-planning skill converts specifications into structured implementation plans and automates the transition to the execution phase. The security analysis identified a low-level risk regarding indirect prompt injection, as the skill processes external specifications and continues the workflow without requiring explicit user confirmation.

  • Socketpass

    No alerts

  • Snykpass

    Risk: LOW · No issues

  • Runlayerpass

    1 file scanned · No issues

What does this agent skill do?

Delegation

For detailed task planning workflows, this skill delegates to spec-kit:task-planning as the canonical implementation. Use this skill for quick planning needs and spec-kit for thorough project plans.

When To Use

  • After specification phase completes
  • Need to design system architecture
  • Need task breakdown for implementation
  • Planning sprints and resource allocation
  • Converting requirements into concrete tasks
  • Defining component interfaces and dependencies

When NOT To Use

  • No specification exists yet (use Skill(attune:project-specification) first)
  • Still exploring problem space (use Skill(attune:project-brainstorming) instead)
  • Ready to execute existing plan (use Skill(attune:project-execution) instead)
  • Need to adjust running project (update plan incrementally, don't restart)

Integration

With superpowers:

  • Uses Skill(superpowers:writing-plans) for structured planning
  • Uses dependency analysis framework

Without superpowers:

  • Standalone planning methodology
  • Task breakdown templates
  • Dependency tracking patterns

Quality Checks

Before completing plan:

  • ✅ All architecture components documented
  • ✅ File Structure section present before tasks
  • ✅ All task files appear in File Structure table
  • ✅ All FRs mapped to tasks
  • ✅ All tasks have acceptance criteria
  • ✅ Dependencies are acyclic
  • ✅ Effort estimates provided
  • ✅ Critical path identified
  • ✅ Risks assessed with mitigations
  • ✅ Sprints balanced by capacity
  • ✅ Global Constraints block copies the spec's binding rules (version floors, dependency limits, exact values) verbatim for every task
  • ✅ Each task that consumes or produces something another task uses names it in an Interfaces line
  • ✅ Review Focus lists up to five inputs or failure modes the spec implies but no task tests, each pinned by a test in the task that owns the code. An empty section means checked and found none
  • ✅ The plan records decisions, not code: signatures, test assertions and commands with their passing output. A plan several times longer than the spec is a code transcript. Replace bodies with signatures

Record the Tradeoff (decision journal)

Planning is where architecture and scope decisions get made: the pattern chosen, the dependency accepted, the work deferred. Record each decision that had real alternatives to docs/tradeoffs.md (draft and confirm):

  • If leyline is installed, invoke Skill(leyline:decision-journal) and append a tradeoff entry with the decision, the options weighed, and what was sacrificed. Set phase to plan. Show the draft and append it on confirmation.
  • Fallback (leyline absent): append to docs/tradeoffs.md using the in-file ENTRY TEMPLATE. Assign the next TR-NNN id.

Post-Completion: Workflow Continuation (REQUIRED)

Automatic Trigger: After Quality Checks pass and docs/implementation-plan.md is saved, MUST auto-invoke the next phase.

When continuation is invoked:

  1. Verify docs/implementation-plan.md exists and is non-empty
  2. Display checkpoint message to user:
    Implementation plan complete. Saved to docs/implementation-plan.md.
    Proceeding to execution phase...
    
  3. Invoke next phase:
    Skill(attune:project-execution)
    

Bypass Conditions (ONLY skip continuation if ANY true):

  • --standalone flag was provided by the user
  • docs/implementation-plan.md does not exist or is empty (phase failed)
  • User explicitly requests to stop after planning

Do NOT prompt the user for confirmation: this is a lightweight checkpoint that continues without waiting. The user can always interrupt if needed.

Exit Criteria

  • docs/implementation-plan.md exists, is non-empty, and passes Quality Checks (acyclic dependencies, FRs mapped, critical path identified).
  • Architecture and scope decisions with alternatives are recorded to docs/tradeoffs.md.
  • The execution phase is auto-invoked unless a bypass condition holds.

Related Skills

  • Skill(superpowers:writing-plans) - Planning methodology (if available)
  • Skill(spec-kit:task-planning) - Task breakdown (if available)
  • Skill(attune:project-specification) - Previous phase
  • Skill(attune:project-execution) - AUTO-INVOKED next phase after planning
  • Skill(attune:mission-orchestrator) - Full lifecycle orchestration

Related Commands

  • /attune:blueprint - Invoke this skill
  • /attune:execute - Next step in workflow

Examples

See /attune:blueprint command documentation for complete examples.

Troubleshooting

Common Issues

If you find circular dependencies in your task graph, break one of the tasks into smaller sub-tasks. If sprint capacity is consistently exceeded, re-estimate tasks using the Fibonacci scale or reduce sprint scope.

Add the canonical catalog link to the repository README so users can inspect current installs and available audits. The publishing guide covers the complete discovery path.

<a href="https://skillzs.dev/skills/athola/claude-night-market/project-planning">View project-planning on skillZs</a>