File-based Planning System

VerifiedSafe

This skill provides a persistent planning system using Markdown files. It enables creating, tracking, and updating plans with phases and steps, recording findings and decisions, and resuming interrupted tasks. It is especially useful for complex coding tasks that require structured, long-term progress tracking beyond a single conversation turn.

Sby Skills Guide Bot
DevelopmentIntermediate
306/2/2026
Claude CodeCursorWindsurfCopilotCodex
#planning#project-management#task-tracking#agent-workflow#file-based

Recommended for

Our review

This skill implements a persistent, file-based planning system that helps AI agents manage complex, multi-step tasks by creating and updating markdown files for tracking phases, progress, and findings.

Strengths

  • Provides a structured, persistent approach that survives conversation resets.
  • Reduces context window pressure by offloading state to files.
  • Encourages granular step tracking and immediate updates, improving agent reliability.
  • Supports easy resumption of interrupted tasks via resume_last_run.

Limitations

  • Relies on the agent correctly calling tools; improper usage can lead to outdated plan files.
  • Limited to the current working directory—no cross-project planning.
  • No built-in collaboration or sharing capabilities among multiple agents.
When to use it

Use this skill for any complex, multi-phase development task where task breakdown and progress tracking are critical and where conversation history alone may be insufficient.

When not to use it

Avoid this skill for very simple, single-step tasks where the overhead of creating and maintaining plan files would be unnecessary.

Security analysis

Safe
Quality score85/100

The skill only manages three markdown planning files and does not perform any destructive, network, or arbitrary code execution operations. It is limited to the listed planning tools, which are harmless.

No concerns found

Examples

Initialize a plan for a web scraper
Initiate a planning session to build a Python web scraper with BeautifulSoup. Include phases for research, setup, implementation, and testing.
Resume an interrupted task
I was working on a plan to develop a REST API but got interrupted. Please resume the last run and continue where I left off.
Record a technical decision
Add a finding: under 'Technical Decisions', record that we chose PostgreSQL over MySQL because of better JSON support.

name: planner description: File-based planning system. allowed-tools:

  • init_planning
  • resume_last_run
  • read_plan
  • update_plan_status
  • mark_step_complete
  • add_finding
  • erase_plans

Planner Skill

This skill implements a persistent planning pattern using markdown files.

Files Managed

  • task_plan.md: Tracks phases, progress, and high-level goal.
  • findings.md: Records research, technical decisions, and resources.
  • progress.md: Detailed session log of actions and thoughts.

Tools

init_planning

Initialize the planning files in the current working directory. For coding task, you do not have to provide rigorous testing.

  • task_description: What needs to be done.
  • phases: List of high-level phases.
  • phase_steps: REQUIRED. List of lists of strings. Each inner list provides the detailed checklist steps for the corresponding phase.
    • Example: [["Research the official API documentation for authentication methods", "Read the developer guides on rate limiting strategies"], ["Set up the initial project structure using Python Poetry and git", "Implement the core logic for the connection manager class"]]

resume_last_run

Reads existing planning files to allow the agent to resume an interrupted task. Returns the content of task_plan.md and the recent log from progress.md.

read_plan

Read the current status from the planning files.

update_plan_status

Update the status of a phase in task_plan.md and log a note in progress.md.

  • phase_name: Name of the phase.
  • status: New status (pending, in_progress, completed).
  • notes: Optional note to append to progress log.

mark_step_complete

Mark a specific step in task_plan.md as complete ([x]).

  • phase_name: The name of the phase containing the step.
  • step_keyword: A unique substring to identify the step line.

add_finding

Record a finding, decision, or resource in findings.md.

  • category: Target section ("Requirements", "Research", "Technical Decisions", "Resources").
  • content: The text to add. For technical decisions, you can use markdown table row format | Decision | Rationale |.

erase_plans

Quickly erase existing plans in artifacts/cache by deleting the three planning files.

  • This is useful when you want to start fresh without any leftover plan files.
  • No parameters needed.

Best Practices for Agents

  1. Start Strong: Always begin complex tasks with init_planning. Break down phases into granular, actionable steps in phase_steps rather than broad goals.
  2. Update Frequently: As you complete sub-tasks, use mark_step_complete IMMEDIATELY. This acts as a "save point" and keeps your reasoning grounded.
  3. Log Discoveries: Don't rely on conversation history for long-term facts. Use add_finding to record important URLs, file paths, or architectural decisions.
  4. Transition Phases: When a phase is done, explicitly use update_plan_status to mark it as completed and the next one as in_progress.
  5. Resume Smart: If you see existing plan files, prefer resume_last_run over starting from scratch.
Related skills