Planning with Files
MIT-licensed Agent Skill for persistent file-based planning across Claude Code, Codex, Cursor, Gemini CLI, OpenCode, Hermes Agent, OpenClaw, Kiro, and other SKILL.md-compatible coding agents, with task_plan.md, findings.md, progress.md, hooks, session recovery, attestation, and opt-in long-running run modes.
Open the source and read safety notes before installing.
Safety notes
- Planning with Files writes persistent planning state into the active project. Review whether `task_plan.md`, `findings.md`, `progress.md`, `.planning/`, and handoff files should be committed, ignored, or scrubbed before sharing.
- The skill uses hooks and helper scripts to re-inject plan context, remind the agent to update progress, run session catchup, and check completion. Inspect the installed hook scripts before enabling them in shared repositories or global agent config.
- Planning files become model context. Do not paste untrusted web content, issue comments, logs, or external instructions into planning files without summarizing and neutralizing prompt-injection text.
- The upstream eval notes describe a prior prompt-injection amplification risk from web fetch/search content being written into planning files and re-read by hooks; current SKILL.md removes WebFetch/WebSearch from allowed tools and documents the security boundary.
- Codex users should merge hook entries into existing hook configs rather than overwriting them, and avoid enabling duplicate workspace plus global hooks that would run twice.
- Autonomous and gated modes are opt-in for long-running runs. Understand whether the host can hard-block, follow up, or only notify before relying on a completion gate.
Privacy notes
- The planning files can contain task goals, source paths, branch names, PR URLs, test output, error logs, research findings, product decisions, customer context, security findings, and operational handoff details.
- Session-catchup workflows inspect local agent session stores such as Claude Code project history, Codex sessions, or other host-specific stores to recover context after `/clear` or compaction.
- Hook-injected planning content is sent to the active model provider as part of the agent context. Keep secrets, access tokens, private incident data, customer records, and unreleased roadmap details out of planning files unless the provider and retention policy are approved.
- Attestation stores hashes of plan content for tamper detection, but it does not encrypt the planning files or make their content safe to publish.
Prerequisites
- An Agent Skills host or Claude Code plugin environment that can load `SKILL.md` instructions.
- Node.js and npx for the documented cross-host `npx skills add` install path, or Claude Code plugin marketplace support for the plugin route.
- For Codex hook automation, Codex skills installed under `.codex/skills` or `~/.codex/skills`, hooks copied into `.codex/hooks.json` or `~/.codex/hooks.json`, and `hooks = true` enabled under `[features]` in `~/.codex/config.toml`.
- A repository or workspace where the agent is allowed to write `task_plan.md`, `findings.md`, `progress.md`, and optional `.planning/` directories.
- A team policy for whether planning files should be committed, ignored, redacted, or kept local when they contain incident, customer, credential-adjacent, or roadmap details.
Schema details
- Install type
- package
- Reading time
- 8 min
- Difficulty score
- 82
- Troubleshooting
- Yes
- Breaking changes
- No
- Scope
- Source repo
- Skill type
- capability-pack
- Skill level
- expert
- Verification
- validated
- Verified at
- 2026-06-18
| Platform | Support | Install path |
|---|---|---|
| claude-code | Native | .claude/skills/<skill-name>/SKILL.md |
| codex | Native | .agents/skills/<skill-name>/SKILL.md |
| windsurf | Native | .windsurf/skills/<skill-name>/SKILL.md |
| gemini | Native | .gemini/skills/<skill-name>/SKILL.md or .agents/skills/<skill-name>/SKILL.md |
| cursor | Adapter | .cursor/rules/<skill-name>.mdc |
| cli | Manual | AGENTS.md or tool-specific context file |
Full copyable content
npx skills add OthmanAdi/planning-with-files --skill planning-with-files -g
# Claude Code plugin route
/plugin marketplace add OthmanAdi/planning-with-files
/plugin install planning-with-files@planning-with-filesAbout this resource
Planning with Files
Planning with Files is an Agent Skill that gives coding agents a durable
three-file planning workflow: task_plan.md for phases and decisions,
findings.md for research and discoveries, and progress.md for session logs
and validation. The key value is simple: the plan lives on disk, so long
coding-agent work can recover after context loss, /clear, compaction,
crashes, or handoff between sessions.
Use it for multi-step implementation, debugging, migration, research, architecture, security, or operations work where the agent needs to preserve intent across many tool calls. Skip it for quick one-shot questions or trivial single-file edits.
Knowledge Freshness
Repository metadata and docs were verified on 2026-06-18. The latest
release was v3.1.3, published on 2026-06-16 as a hotfix for invalid YAML
frontmatter in v3.1.2. GitHub metadata reported more than 23,000 stars, active
updates on 2026-06-16, an MIT license, and topics covering Claude, Codex,
Cursor, agent skills, planning, autonomous agents, context engineering, and
long-running agents.
The skill supports many host variants, but hook behavior depends on each host. Before relying on automation, verify the exact install path, hook feature flag, and lifecycle events for your host.
Retrieval Sources
This listing is grounded in:
- The canonical
skills/planning-with-files/SKILL.mdfile. - Installation, Codex setup, quickstart, workflow, eval, migration, changelog, and release documentation from the upstream repository.
- Current GitHub repository metadata and release metadata.
Core Install Paths
For Agent Skills hosts that use the skills installer:
npx skills add OthmanAdi/planning-with-files --skill planning-with-files -g
For Claude Code's plugin marketplace route:
/plugin marketplace add OthmanAdi/planning-with-files
/plugin install planning-with-files@planning-with-files
For Codex, install the .codex/skills/planning-with-files directory and merge
the .codex/hooks.json lifecycle entries into the project or global Codex hook
config. Then enable hooks:
[features]
hooks = true
Do not overwrite an existing global hook config without merging. Duplicate workspace and global hook installs can produce duplicate reminders.
Capability Scope
| Area | Planning with Files Coverage |
|---|---|
| Persistent plan | Creates and maintains task_plan.md, findings.md, and progress.md in the project |
| Skill metadata | Canonical SKILL.md with description, allowed tools, hooks, version metadata, and user invocation |
| Hooks | UserPromptSubmit, PreToolUse, PostToolUse, Stop, and PreCompact behavior where the host supports them |
| Session recovery | session-catchup.py reads host session stores to recover context after /clear or compaction |
| Parallel work | .planning/<date-slug>/ isolated plan directories plus active-plan resolution |
| Completion checks | Scripts for checking phase completion and, in opt-in modes, deliberate completion gating |
| Attestation | Plan hash attestation scripts that can refuse to inject changed plan content until re-attested |
| Long-running modes | v3 autonomous and gated modes for reducing recitation or adding a deliberate completion gate |
| Host variants | Claude Code, Codex, Cursor, Copilot, Gemini CLI, Kiro, Hermes, OpenCode, Continue, Pi, OpenClaw, Antigravity, Kilocode, AdaL, and others |
| Templates | Starter templates for task plans, findings, progress, and autonomous plans |
| Evals | Upstream eval docs report structured-workflow fidelity testing and blind A/B comparisons |
Core Workflow
The skill teaches the agent to create the three planning files before complex work starts, update findings after research, update progress after actions, mark phases complete, and log errors instead of repeating the same failed approach.
The core rhythm is:
- Create or read
task_plan.md,findings.md, andprogress.md. - Break the work into phases with
Statusfields. - Write research and decisions into
findings.md. - Write actions, test results, and errors into
progress.md. - Before major decisions, re-read the plan.
- Before stopping, verify that every required phase is complete.
This is useful for agents because it moves durable task state out of the context window and into project files the agent can re-read.
Codex Notes
The Codex docs describe two install scopes:
- Workspace install: commit
.codex/into the repository so the team shares the same skill and hook behavior. - Personal install: copy the skill and hooks into
~/.codex/.
Codex hook automation requires hooks = true under [features] in
~/.codex/config.toml. The docs also mention codex_hooks = true as a
deprecated alias and note that current Codex hooks documentation disables hooks
on Windows.
Production Rules
Planning files are not inert notes. They are read by the agent and can be re-injected into model context by hooks. Treat them like prompt-bearing workflow state:
- Summarize untrusted web or issue content before writing it into planning files.
- Avoid storing secrets, tokens, internal incident details, customer data, or unreleased roadmap material in files that might be committed or shared.
- Review hook scripts before enabling them globally.
- Use attestation when plan integrity matters.
- Keep autonomous and gated modes opt-in until you know how the host enforces Stop behavior.
Use Cases
- Preserve context across long Claude Code, Codex, Cursor, or OpenCode coding tasks.
- Keep implementation phases, errors, and validation state visible during a migration or refactor.
- Recover a task after
/clear, compaction, or a crash. - Coordinate multiple agents or terminals through isolated
.planning/directories. - Run research-heavy workflows where findings need to survive context loss.
- Add a completion check before an agent declares a large task done.
Source Review
Verified on 2026-06-18:
- GitHub metadata reported
OthmanAdi/planning-with-filesas an MIT-licensed Python repository with the descriptionPersistent file-based planning for AI coding agents and long-running agentic tasks, latest releasev3.1.3published on 2026-06-16, and more than 23,000 stars. - The canonical
skills/planning-with-files/SKILL.mddeclares the skill name, quoted description,user-invocable: true, allowed tools, lifecycle hook commands, metadata version3.1.3, and instructions for persistent planning files, session catchup, rules, templates, scripts, attestation, and parallel plan isolation. - The README describes the project as persistent file-based planning for AI
coding agents, with
task_plan.md,findings.md, andprogress.md, support for the SKILL.md standard, and host-specific integrations. - The install docs document Claude Code plugin install, manual plugin install, skill-only install, verification, updates, and platform-specific docs.
- The Codex docs document
.codex/skills,.codex/hooks.json, Codex hook feature flags, workspace or personal install scope, lifecycle hooks, and warnings about merging existing hook configs. - The quickstart documents the three-file workflow, phase status updates, findings updates, progress updates, isolated plan directories, and completion checks.
- The eval docs report a structured-workflow benchmark using Anthropic's
skill-creator framework, with
with_skillsatisfying 29 of 30 assertions and blind A/B comparators preferring the skill output in 3 of 3 comparisons for the tested tasks. - The migration docs describe v3 autonomous mode, gated mode, a structured run-ledger, phase coordination fields, attestation, and no default behavior change from v2.43.0 without explicit opt-in.
- Release
v3.1.3fixed invalid YAML frontmatter from v3.1.2 by quoting the English SKILL.md descriptions and added tests that parse every SKILL.md frontmatter as YAML.
Source citations
Add this badge to your README
How it compares
Planning with Files side by side with 3 alternatives on trust, install, platform support, and disclosed safety notes — all from reviewed registry metadata.
| Field | Planning with Files MIT-licensed Agent Skill for persistent file-based planning across Claude Code, Codex, Cursor, Gemini CLI, OpenCode, Hermes Agent, OpenClaw, Kiro, and other SKILL.md-compatible coding agents, with task_plan.md, findings.md, progress.md, hooks, session recovery, attestation, and opt-in long-running run modes. Open dossier | Context Engineering Agent Skills MIT-licensed Agent Skills collection for context engineering, harness engineering, multi-agent architectures, filesystem context, memory systems, tool design, evaluation, hosted agents, and production agent operating loops for Claude Code, Cursor, Codex, and Open Plugins-compatible agent tools. Open dossier | Addy Osmani Agent Skills Addy Osmani's production-grade Agent Skills pack for AI coding agents, with lifecycle slash commands, engineering workflow skills, review personas, quality gates, and cross-agent setup guidance for Claude Code, Cursor, Gemini CLI, Antigravity CLI, OpenCode, GitHub Copilot, and other agents. Open dossier | Supabase Agent Skills Official Supabase Agent Skills for AI coding agents working with Supabase Database, Auth, Edge Functions, Realtime, Storage, Vectors, CLI, MCP, RLS, migrations, and Postgres performance. Open dossier |
|---|---|---|---|---|
| Trust | ||||
| Install risk | Review first | Review first | Review first | Review first |
| Notes | Safety ✓ Privacy ✓ | Safety ✓ Privacy ✓ | Safety ✓ Privacy ✓ | Safety ✓ Privacy ✓ |
| Category | skills | skills | skills | skills |
| Source | source-backed | source-backed | source-backed | source-backed |
| Author | Ahmad Othman Ammar Adi | Muratcan Koylan | Addy Osmani | Supabase |
| Added | 2026-06-18 | 2026-06-18 | 2026-06-18 | 2026-06-18 |
| Platforms | Claude CodeCodexWindsurfGeminiCursorCLIContinue | Claude CodeCodexWindsurfGeminiCursorCLI | Claude CodeCodexWindsurfGeminiCursorCLI | Claude CodeCodexWindsurfGeminiCursorCLI |
| Source repo | — | — | — | — |
| Safety notes | ✓Planning with Files writes persistent planning state into the active project. Review whether `task_plan.md`, `findings.md`, `progress.md`, `.planning/`, and handoff files should be committed, ignored, or scrubbed before sharing. The skill uses hooks and helper scripts to re-inject plan context, remind the agent to update progress, run session catchup, and check completion. Inspect the installed hook scripts before enabling them in shared repositories or global agent config. Planning files become model context. Do not paste untrusted web content, issue comments, logs, or external instructions into planning files without summarizing and neutralizing prompt-injection text. The upstream eval notes describe a prior prompt-injection amplification risk from web fetch/search content being written into planning files and re-read by hooks; current SKILL.md removes WebFetch/WebSearch from allowed tools and documents the security boundary. Codex users should merge hook entries into existing hook configs rather than overwriting them, and avoid enabling duplicate workspace plus global hooks that would run twice. Autonomous and gated modes are opt-in for long-running runs. Understand whether the host can hard-block, follow up, or only notify before relying on a completion gate. | ✓These skills alter how agents select context, delegate work, persist state, design tools, evaluate outputs, and operate autonomous loops; use them as engineering guidance, not as automatic authority to change a production agent system. Filesystem-context and memory-system patterns can cause agents to write durable plans, scratchpads, logs, summaries, preferences, or shared handoff files. Keep cleanup, ownership, and review rules explicit. Harness-engineering, hosted-agent, and evaluation workflows can launch long-running loops, background agents, benchmark suites, paid model calls, or remote sandbox work. Require budgets, kill switches, rollback rules, and approval gates. Tool-design guidance can change MCP schemas, tool descriptions, return formats, and error contracts. Test routing and compatibility before deploying changes to users. Benchmark results are source evidence for this repository's claims, but they are workload-specific. Re-run or adapt benchmarks before relying on the reported routing numbers in a different agent stack. | ✓The slash commands are designed to guide real coding, testing, reviewing, committing, and shipping work; keep edits, commits, pushes, CI changes, and deploys behind the host's normal approval controls. `/build auto` is explicitly intended to generate a plan and implement multiple tasks in one approved pass. Use it on bounded specs, review the generated plan first, and stop on test failures or risky changes. The skills encode durable engineering workflows, not guaranteed-current framework APIs. Follow the source-driven-development guidance and verify current documentation before applying generated code. Security, CI/CD, observability, migration, and launch skills can touch production-sensitive systems. Require dry-run plans, rollback notes, and environment scoping before approving operational commands. Review personas and quality gates are useful second opinions, but they do not replace maintainer review, domain-specific tests, threat modeling, or release sign-off. | ✓The skills guide agents toward Supabase schema, auth, RLS, migration, MCP, and Postgres work that can affect real user data; generated SQL and policies need human review. The Supabase skill explicitly treats RLS, exposed schemas, service-role keys, JWT claims, views, storage policies, and SECURITY DEFINER functions as security-sensitive areas. Do not let an agent apply migrations or production SQL just because the skill suggests a workflow; run advisors, inspect generated SQL, and verify against the intended environment. The repository includes Supabase MCP configuration for docs-only MCP access. Project-scoped MCP or database access still needs proper authentication, least privilege, and review. |
| Privacy notes | ✓The planning files can contain task goals, source paths, branch names, PR URLs, test output, error logs, research findings, product decisions, customer context, security findings, and operational handoff details. Session-catchup workflows inspect local agent session stores such as Claude Code project history, Codex sessions, or other host-specific stores to recover context after `/clear` or compaction. Hook-injected planning content is sent to the active model provider as part of the agent context. Keep secrets, access tokens, private incident data, customer records, and unreleased roadmap details out of planning files unless the provider and retention policy are approved. Attestation stores hashes of plan content for tamper detection, but it does not encrypt the planning files or make their content safe to publish. | ✓Context-engineering work often touches prompts, system instructions, tool definitions, retrieved documents, message history, tool outputs, logs, scratch files, memory stores, benchmark prompts, and model responses. Do not persist secrets, customer data, private source code, incident data, unpublished strategy, or regulated records into scratchpads, skill examples, benchmark fixtures, or shared agent workspaces. If benchmark runners or hosted-agent examples call external models or remote sandboxes, review what prompts, traces, files, and logs are sent outside the local workspace. Agent memory and filesystem-context patterns should include deletion, redaction, retention, and access-control rules before being used with private projects. | ✓Using the pack with an AI agent can expose repository code, product requirements, architecture notes, tests, CI logs, deployment settings, incidents, security findings, and launch plans to the configured model provider. Do not paste secrets, customer data, private incident records, production credentials, unpublished roadmap details, or proprietary compliance material into public prompts, issues, screenshots, or PR bodies. Agent personas and review workflows may ask for browser traces, performance data, logs, build output, dependency lists, and environment details; redact tokens and private URLs before sharing artifacts. | ✓Supabase tasks can involve schemas, SQL, RLS policies, migrations, auth settings, JWT claims, storage paths, Edge Function code, logs, and customer data. Keep SUPABASE_ACCESS_TOKEN, service_role keys, database passwords, JWT secrets, project refs, connection strings, OAuth secrets, and private schema dumps out of prompts, screenshots, public PRs, and committed configs. When using Supabase MCP or CLI tools, the connected agent may see project metadata, database structure, logs, or SQL results depending on granted permissions. Docs-only MCP access is safer than project MCP access, but user queries and docs snippets can still be forwarded into the configured model provider. |
| Prerequisites |
|
|
|
|
| Install | | | | |
| Config | | — | — | — |
| Citations | ||||
| Claim | Unclaimed | Unclaimed | Unclaimed | Unclaimed |
Signals
Loading live community signals…
A short, calm digest of reviewed Claude resources. Unsubscribe any time.