OpenParable
Skip to content
← Back to skills

Project Planning

Productivity
project-planning

Project Planning is an Agent Skill for productivity published in the athola/claude-night-market repository on GitHub: a SKILL.md instruction file an AI agent can load to do this task.

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

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/athola/claude-night-market/blob/HEAD/plugins/attune/skills/project-planning/SKILL.md and all supporting files. Report provenance, permissions, scripts, dependencies, and security risks. Propose an exact installation into .agents/skills/project-planning, 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.

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; use 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
  • Applies checkpoint-based execution patterns
  • 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

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 (the decision, the options weighed, and what was sacrificed; set phase to plan). Show the draft; append 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, not an interactive gate. 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.