Skip to main content
skillsSource-backedReview first Safety Privacy

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.

by Ahmad Othman Ammar Adi·added 2026-06-18·
HarnessClaude CodeCodexWindsurfGeminiCursorCLIContinue
Level:expertType:capability-packVerified:validated
Review first review before installing

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
Source repository stats
Scope
Source repo
Skill and platform metadata
Skill type
capability-pack
Skill level
expert
Verification
validated
Verified at
2026-06-18
Retrieval sources
https://github.com/OthmanAdi/planning-with-fileshttps://raw.githubusercontent.com/OthmanAdi/planning-with-files/master/skills/planning-with-files/SKILL.mdhttps://raw.githubusercontent.com/OthmanAdi/planning-with-files/master/docs/installation.mdhttps://raw.githubusercontent.com/OthmanAdi/planning-with-files/master/docs/codex.mdhttps://raw.githubusercontent.com/OthmanAdi/planning-with-files/master/docs/quickstart.mdhttps://raw.githubusercontent.com/OthmanAdi/planning-with-files/master/docs/evals.mdhttps://raw.githubusercontent.com/OthmanAdi/planning-with-files/master/MIGRATION.md
Tested platforms
Claude CodeCodexCursorGitHub CopilotMastra CodeGemini CLIKiroHermes AgentCodeBuddyFactoryAI DroidOpenCodeContinuePi AgentOpenClawAntigravityKilocodeAdaL CLI
PlatformSupportInstall path
claude-codeNative.claude/skills/<skill-name>/SKILL.md
codexNative.agents/skills/<skill-name>/SKILL.md
windsurfNative.windsurf/skills/<skill-name>/SKILL.md
geminiNative.gemini/skills/<skill-name>/SKILL.md or .agents/skills/<skill-name>/SKILL.md
cursorAdapter.cursor/rules/<skill-name>.mdc
cliManualAGENTS.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-files

About 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.md file.
  • 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:

  1. Create or read task_plan.md, findings.md, and progress.md.
  2. Break the work into phases with Status fields.
  3. Write research and decisions into findings.md.
  4. Write actions, test results, and errors into progress.md.
  5. Before major decisions, re-read the plan.
  6. 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-files as an MIT-licensed Python repository with the description Persistent file-based planning for AI coding agents and long-running agentic tasks, latest release v3.1.3 published on 2026-06-16, and more than 23,000 stars.
  • The canonical skills/planning-with-files/SKILL.md declares the skill name, quoted description, user-invocable: true, allowed tools, lifecycle hook commands, metadata version 3.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, and progress.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_skill satisfying 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.3 fixed 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

Show that Planning with Files is listed on HeyClaude. Paste this Markdown into your README — it renders the badge and links back to this page.

Listed on HeyClaude
[![Listed on HeyClaude](https://heyclau.de/badge/skills/planning-with-files.svg)](https://heyclau.de/entry/skills/planning-with-files)

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.

FieldPlanning 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 riskReview firstReview firstReview firstReview first
Notes Safety Privacy Safety Privacy Safety Privacy Safety Privacy
Categoryskillsskillsskillsskills
Sourcesource-backedsource-backedsource-backedsource-backed
AuthorAhmad Othman Ammar AdiMuratcan KoylanAddy OsmaniSupabase
Added2026-06-182026-06-182026-06-182026-06-18
Platforms
Claude CodeCodexWindsurfGeminiCursorCLIContinue
Claude CodeCodexWindsurfGeminiCursorCLI
Claude CodeCodexWindsurfGeminiCursorCLI
Claude CodeCodexWindsurfGeminiCursorCLI
Source repo
Safety notesPlanning 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 notesThe 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
  • 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.
  • Claude Code plugin support, Cursor Open Plugins support, or an agent host that can load Agent Skills or custom instruction files.
  • A project where context-window behavior, multi-agent structure, tool design, memory, evaluation, or harness reliability is a real design concern.
  • A version-controlled workspace for any scripts, examples, benchmark artifacts, or generated skill changes.
  • Human review before applying benchmark-derived skill changes, modifying persistent agent memory, changing tool schemas, or deploying autonomous harness loops.
  • Claude Code plugin support, an Agent Skills compatible installer, or an agent/editor that can load Markdown instruction files.
  • A software project where lifecycle guidance for specs, planning, implementation, testing, review, simplification, or launch is appropriate.
  • A version-controlled workspace with a known approval model for edits, tests, commits, pushes, and deployments.
  • Current framework, platform, and API documentation for any concrete implementation work produced under these skills.
  • AI coding agent or skill installer compatible with Agent Skills repositories.
  • Supabase project, local Supabase app, or planned Supabase integration.
  • Current Supabase docs access, Supabase CLI help, or Supabase MCP server access for exact commands and API details.
  • Database access appropriate to the task when validating SQL, RLS, migrations, advisors, or performance fixes.
Install
npx skills add OthmanAdi/planning-with-files --skill planning-with-files -g
/plugin marketplace add muratcankoylan/Agent-Skills-for-Context-Engineering
/plugin marketplace add addyosmani/agent-skills
npx skills add supabase/agent-skills
Config
[features]
hooks = true
Citations
ClaimUnclaimedUnclaimedUnclaimedUnclaimed

Signals

Loading live community signals…

More like this, weekly

A short, calm digest of reviewed Claude resources. Unsubscribe any time.