Skip to content
cccskills
FreePublished on GitHub

planning-with-files

Keeps multi-step work organized with Markdown files for the plan, research notes, and final deliverable. Tracks completed phases, decisions, and errors so the agent can revisit goals and resume work with durable records.

OriginalShow the original description

Use this by default for non-trivial multi-step work that needs persistent planning, progress tracking, or durable notes on disk. Trigger when a task will likely span multiple tool calls, research steps, verification loops, or enough context that the plan should not live only in transient chat memory.

See how to install

Good for

  • Tracking progress through a multi-step task
  • Keeping research findings and sources on disk
  • Resuming work after a pause
  • Recording decisions and errors during complex work

Files included (3)

  • SKILL.md4.2 KB
  • examples.md4.3 KB
  • reference.md3.4 KB

SKILL.md (original)

Review the instructions the agent will receive before you install.

Planning with Files

Work like Manus: use persistent markdown files as your working memory on disk.

This is not just an optional planning style. It should be the default persistence layer for complex Codex work.

Use it proactively when:

  • the task will likely take more than a few tool calls
  • progress needs to be tracked across phases
  • findings or evidence must be preserved while working
  • the task may branch, pause, or resume later
  • relying on chat context alone would be fragile

Quick Start

Before ANY complex task:

  1. Create task_plan.md in the working directory
  2. Define phases with checkboxes
  3. Update after each phase - mark [x] and change status
  4. Read before deciding - refresh goals in attention window

The 3-File Pattern

For every non-trivial task, create THREE files:

FilePurposeWhen to Update
task_plan.mdTrack phases and progressAfter each phase
notes.mdStore findings and researchDuring research
[deliverable].mdFinal outputAt completion

Core Workflow

Loop 1: Create task_plan.md with goal and phases
Loop 2: Research → save to notes.md → update task_plan.md
Loop 3: Read notes.md → create deliverable → update task_plan.md
Loop 4: Deliver final output

The Loop in Detail

Before each major action:

Read task_plan.md  # Refresh goals in attention window

After each phase:

Edit task_plan.md  # Mark [x], update status

When storing information:

Write notes.md     # Don't stuff context, store in file

task_plan.md Template

Create this file FIRST for any complex task:

# Task Plan: [Brief Description]

## Goal
[One sentence describing the end state]

## Phases
- [ ] Phase 1: Plan and setup
- [ ] Phase 2: Research/gather information
- [ ] Phase 3: Execute/build
- [ ] Phase 4: Review and deliver

## Key Questions
1. [Question to answer]
2. [Question to answer]

## Decisions Made
- [Decision]: [Rationale]

## Errors Encountered
- [Error]: [Resolution]

## Status
**Currently in Phase X** - [What I'm doing now]

notes.md Template

For research and findings:

# Notes: [Topic]

## Sources

### Source 1: [Name]
- URL: [link]
- Key points:
  - [Finding]
  - [Finding]

## Synthesized Findings

### [Category]
- [Finding]
- [Finding]

Critical Rules

1. ALWAYS Create Plan First

Never start a complex task without task_plan.md. This is non-negotiable.

2. Read Before Decide

Before any major decision, read the plan file. This keeps goals in your attention window.

3. Update After Act

After completing any phase, immediately update the plan file:

  • Mark completed phases with [x]
  • Update the Status section
  • Log any errors encountered

4. Store, Don't Stuff

Large outputs go to files, not context. Keep only paths in working memory.

5. Log All Errors

Every error goes in the "Errors Encountered" section. This builds knowledge for future tasks.

When to Use This Pattern

Use 3-file pattern for:

  • Multi-step tasks (3+ steps)
  • Research tasks
  • Building/creating something
  • Tasks spanning multiple tool calls
  • Anything requiring organization

Skip for:

  • Simple questions
  • Single-file edits
  • Quick lookups

Anti-Patterns to Avoid

Don'tDo Instead
Use TodoWrite for persistenceCreate task_plan.md file
State goals once and forgetRe-read plan before each decision
Hide errors and retryLog errors to plan file
Stuff everything in contextStore large content in files
Start executing immediatelyCreate plan file FIRST

Advanced Patterns

See reference.md for:

  • Attention manipulation techniques
  • Error recovery patterns
  • Context optimization from Manus

See examples.md for:

  • Real task examples
  • Complex workflow patterns

Reviews

No reviews yet. Tell others what you thought.

Comments

No login needed. Share how it worked for you, ask a question, or note where it did not run.

No comments yet. Be the first to write one.

Comments are published right away. Do not include personal information such as email addresses or phone numbers. Up to 2 URLs.

0 / 1,000 characters

This form is protected by reCAPTCHA, and the Google Privacy Policy and Terms of Service apply.

More skills from this repository

agent-identifier

FreeSummary

Create and configure Claude Code agents using Markdown files with YAML configuration headers. Define when each agent should run, write its responsibilities and workflow, choose models and tools, and check configuration and triggering behavior.

  • Create a Claude Code subagent
  • Define triggering conditions with concrete examples
  • Configure an agent's model, color, and tools
Galaxy-Dawn/claude-scholar5.9KUpdated Oct 19, 2026

Add datasets, models, and other components to machine learning projects using consistent registration and creation patterns. The skill guides file placement, configuration, and automatic module loading so new components fit the project's established architecture.

  • Adding a registered Dataset class
  • Creating a model driven by configuration
  • Wiring registration and creation logic in a new module
Galaxy-Dawn/claude-scholar5.9KUpdated Oct 19, 2026

bug-detective

FreeSummary

Investigate code errors through a structured process using reproduction steps, logs, and testable explanations. The workflow guides fault isolation, fixes, and follow-up checks, with common error patterns for Python, JavaScript/TypeScript, and Bash/Zsh.

  • Investigating an error using logs and reproduction steps
  • Finding why code broke after a recent change
  • Troubleshooting common shell script errors
Galaxy-Dawn/claude-scholar5.9KUpdated Oct 19, 2026

Check academic references for existence, accurate publication details, and support for the claims being cited. This guide explains how to verify sources, obtain bibliography entries, and flag references that cannot be confirmed.

  • Checking references suggested by AI
  • Verifying authors, titles, and publication years
  • Checking whether a paper supports a cited claim
Galaxy-Dawn/claude-scholar5.9KUpdated Oct 19, 2026

Review code changes and pull requests for correctness, security, performance, and test quality. The skill helps prioritize issues, write specific and constructive feedback, and create shared review checklists and standards for a development team.

  • Reviewing code changes and pull requests
  • Writing review comments with clear priorities and fixes
  • Creating shared review checklists for a team
Galaxy-Dawn/claude-scholar5.9KUpdated Oct 19, 2026

Create reusable slash commands, prompts invoked by typing a slash, for Claude Code. The skill explains Markdown structure, arguments, file references, tool permissions, and plugin integration so recurring tasks can follow a defined workflow.

  • Turning recurring prompts into slash commands
  • Creating review commands with arguments and file references
  • Sharing project-specific commands with a team
Galaxy-Dawn/claude-scholar5.9KUpdated Oct 19, 2026

See all skills by Galaxy-Dawn

Report a problem with this skill