Open Source Alternatives
  • Alternatives
  • Categories
    Categories by size1,196 projects
    • Developer Tools617
    • AI & Machine Learning520
    • Business & Productivity290
    • Web Development215
    • Security & Monitoring180
    • Communication & Collaboration159
    • IT Management151
    • LLMOps & AI Tooling132
    • Cloud & Hosting129
    • Product & Project Management126
    Browse all 21 categoriesDesign & Creative, DevOps & CI/CD and 9 more
  • Blog
  • Advertise
SearchNotion, Slack, password manager.../
Submit
Open Source Alternatives
  • Alternatives
    • Developer Tools617
    • AI & Machine Learning520
    • Business & Productivity290
    • Web Development215
    • Security & Monitoring180
    • Communication & Collaboration159
    • Browse all 21 categories
  • Blog
  • Advertise
Submit your project

New open source projects by email

The projects we add and every new guide. Free, unsubscribe any time.

Open Source Alternatives LogoOpen Source Alternatives

Handpicked Open Source Alternatives to Paid Softwares

Add Open Source Alternatives as a preferred source on Google

Product

  • Categories
  • Tag
  • Advertise

Resources

  • Blog
  • Collection
  • Submit

Company

  • Privacy Policy
  • Terms of Service
  • Refund Policy
  • Sitemap

Alternatives

  • Claude Code
  • Jira
  • Notion
  • Slack
  • Linear
  • Wispr Flow
  • All alternatives
© 2026 Open Source Alternatives. All rights reserved.
Open SourceAlternatives
Home/Categories/Developer Tools/Planning With Files
icon of Planning With Files

Planning With Files

  • 28K stars
  • MIT
  • Active this week
  • Last commit 2 days ago

Last verified Nov 10, 2026

Manage AI coding agent task plans in disk files that survive /clear, context compaction, and session crashes. MIT licensed, no server needed.

Visit websiteGitHub28K stars
image of Planning With Files
TL;DR

Planning With Files is a planning skill for AI coding agents that keeps task_plan.md, findings.md, and progress.md in your project directory. When a session ends, the context compacts, or /clear fires, those three files remain on disk and the next session resumes from the saved state. MIT licensed with no server requirement. Best for developers running multi-session tasks or refactors where the agent needs to pick up where it left off.

Read the full breakdownHide the full breakdownWho it is for, how it works, trade-offs, the quick start and the FAQ
who it's for

Who Planning With Files is for#

Developers running multi-session coding tasks

Keeps the goal, current phase, and next step in the project directory across sessions. When the context compacts or /clear fires, the next session picks up from the saved resume point in progress.md rather than starting from scratch. Best for refactors, bug investigations, and feature builds that span more than one conversation.

Skip if:

Tasks that fit in a single session with no risk of context reset. If the entire plan and execution are short enough to stay in context, the files add overhead without benefit.

Developers switching between multiple AI coding tools

The Agent Skills standard means the same planning files work across Claude Code, Codex, Cursor, OpenCode, Pi, and others. If the team uses different agents for different tasks, the plan in the project directory is accessible to all of them without reformatting or re-entry.

Skip if:

Teams with a single agent and stable session management who have not hit context limits. The cross-agent portability is the main value here; a single-agent workflow with short tasks gains less.

Engineers building or evaluating autonomous agents

The gated completion mode and structured plan files are directly useful for evaluating whether an agent follows a multi-step plan to completion. Published benchmarks (96.7% pass rate, 3/3 blind A/B wins) make it possible to compare agent behavior with and without the skill. File-based planning of this kind is documented as an approach for long-running agent systems.

Skip if:

Agent evaluation frameworks with their own plan-tracking mechanisms. If your evaluation pipeline already tracks task state externally, the files may duplicate rather than supplement it.

the problem

The problem it solves#

AI coding agents have no memory between sessions. When you clear the conversation, hit the context limit, or switch between tools, any task plan held only in the chat disappears. The agent either starts over, invents a plan from scratch, or requires you to manually re-establish the goal and next step. For long tasks (refactors, feature builds, multi-step investigations), this is a recurring cost paid at the start of every new session.

The workaround most developers use is pasting context manually into each new session or keeping a separate task document open and copying from it. Neither approach is durable: the plan is not version-controlled with the code, the agent cannot read it automatically, and a mid-task crash or unexpected /clear leaves the work in an unknown state with no structured recovery path.

how Planning With Files solves it

How it solves it#

Three planning files kept on disk

Keeps task_plan.md (goal and phases), findings.md (decisions and what to avoid), and progress.md (completed steps and the resume point) in your project directory. All three are plain markdown, version-controlled with your code, and readable by any agent or developer without special tooling.

Lifecycle hook injection

Activated integrations surface selected planning context at supported lifecycle points, so the agent sees the current plan and next step at the start of each turn without manual copy-paste. Claude Code, Codex CLI, Hermes Agent, and others each get their own host-specific integration.

Optional gated completion mode

A configurable gate can block the agent from stopping a task when phases remain unfinished, with retry and stall limits. This prevents the common failure mode where the agent reports done before the plan is fully executed. Some hosts can only notify; the gate requires host support.

60+ agent support via Agent Skills standard

Installs across 60+ AI coding agents (Claude Code, Codex, Cursor, OpenCode, Pi, Hermes Agent, DeepSeek, and more) via the Agent Skills standard. Native plugins exist for first-class hosts. Available via npm, the Claude Code plugin marketplace, or the skills.sh registry.

Parallel work and worktree support

Each parallel task can be pinned to its own plan file, or separate worktrees can hold independent plans. This prevents one shared plan from colliding with concurrent agent sessions working on different branches or tasks.

strengths · trade-offs

Strengths and trade-offs#

Strengths

  • MIT license with no server requirementMIT licensed and runs entirely in the project directory. No server, no database, and no paid tier. The three planning files are plain markdown and version-controlled with your code. Install once and all sessions on the same project share the same plan state.
  • Benchmarked: 96.7% pass rate and 3 blind A/B winsPublished benchmarks show a 96.7% assertion pass rate (29 of 30) with the skill enabled. Three blind A/B tests all favored the skill over running without it. This is the only planning skill in the category with published, verifiable evaluation results.
  • Plan files are version-controlled with the codeThe three planning files are plain markdown and tracked in git alongside the codebase. Any change to the plan is a diff, any revert is a git reset, and the plan history is part of the project history. No external service, subscription, or separate database holds the work state.

Trade-offs

  • -Recovery depends on what was saved before the resetAutomatic recovery reads only what was written to the three planning files before the session ended. Any work or decision not saved to progress.md or findings.md before a /clear or crash is not recoverable. Discipline about saving state mid-task is a user responsibility; the skill cannot reconstruct unsaved context.
  • -Hooks and native plugin setup varies by hostThe npx install command is cross-agent, but lifecycle hooks and native plugins require additional configuration steps that differ per host. Claude Code, Codex, and others each have their own setup; some hosts can only notify rather than inject context or gate completion. Consult the per-host setup guide before expecting full functionality.
versus alternatives

Planning With Files vs alternatives#

Planning With Files vs GitHub Copilot

GitHub Copilot and Planning With Files overlap in the AI coding agent category, but they serve different roles. Copilot generates code inline and answers questions about the codebase, but it has no native mechanism for persistent task planning across sessions. When a Copilot chat session ends or the context resets, any in-flight plan stored in that conversation is gone.

FeaturePlanning With FilesGitHub Copilot
LicenseMIT (open source)Proprietary
Persistent planning filesYes (three files on disk)No
Cross-session recoveryYesNo
Self-hostingRuns in project directoryNo self-hosted option

Planning With Files is the better choice when the task spans more than one conversation or agent session, when /clear is part of your workflow, or when you need a version-controlled record of what the agent decided and why. GitHub Copilot is the better fit for inline code generation and single-session question-answering where persistent planning is unnecessary overhead.

Planning With Files vs Cursor

Cursor is a paid AI-first code editor with built-in AI chat, but it has no structured mechanism for persisting task plans across conversations in a recoverable format. Planning With Files runs inside any project, including one open in Cursor, and adds the planning persistence layer.

FeaturePlanning With FilesCursor
LicenseMIT (open source)Proprietary
Persistent task planningYes (task_plan.md, findings.md, progress.md)No structured plan persistence
Agent compatibility60+ agentsCursor AI only

The two are complementary. Planning With Files can run inside a Cursor project to give Cursor's AI a plan it can read and resume. For short Cursor sessions that do not hit context limits, the planning files add overhead without benefit. For multi-session tasks where Cursor's context resets mid-work, the skill fills the gap.

install · quick start

Quick start#

bash
Install the planning skill globally via npm; hooks and native plugins for specific agents need additional per-host setup after the base install.
```bash
npm install -g planning-with-files
```
tech stack · detected from GitHub

What it's built on#

Languages
PythonTypeScript
frequently asked

FAQ#

How does Planning With Files survive a /clear or context reset?

When /clear fires or the context compacts, the three planning files (task_plan.md, findings.md, progress.md) remain on disk in the project directory. The next session reads those files to find the current phase, the recorded findings, and the resume point. Recovery depends on what was written to those files before the reset; any unsaved in-conversation work is lost, so the skill works best when the agent saves state regularly.

Which AI coding agents does Planning With Files support?

It installs across 60+ agents via the Agent Skills standard. Native plugins exist for Claude Code, Codex CLI, Qoder CLI, Pi, Hermes Agent, OpenCode, and DeepSeek. For agents without a native plugin, install via npm with npm install -g planning-with-files, or use the Claude Code plugin marketplace. Lifecycle features (hook injection, gated completion) depend on what the host supports; consult the per-host setup guide for details.

Is Planning With Files free to use?

Yes. The repository is MIT licensed: free to run, modify, and use commercially. No paid tier, no cloud service, and no account required. The three planning files live in your project directory alongside your code.

How do I install Planning With Files?

Run npx skills add OthmanAdi/planning-with-files --skill planning-with-files -g in a terminal. It is also available via the Claude Code plugin marketplace and the skills.sh registry. After the base install, hooks and native plugins for specific agents may need additional configuration steps described in the per-host setup guide.

What is the gated completion mode?

An optional mode that blocks the agent from marking a task done when plan phases remain unfinished, with configurable retry and stall limits. It prevents the common failure where the agent reports completion before all checklist items are addressed. The gate requires host support; on hosts that can only notify, it fires a notification instead of blocking.

also worth a look

Similar open-source tools#

Nuphos

Featured

Alternative toConductor

Agent workspace for teams running Claude Code or Codex

  • 372 GitHub stars
  • Apache-2.0Licence Apache-2.0

REA (Reverse Engineer Anything)

Featured

Alternative toRevEng.AI

AI-powered reverse engineering for binaries, apps, and assemblies.

  • 441,247 GitHub stars
  • MITLicence MIT

rakazo

Featured

Alternative toGrok Bot

AI teammates you own: your keys, your model, your machine.

  • 7,478 GitHub stars
  • Apache-2.0Licence Apache-2.0

Agent Reach

Featured

Alternative toFirecrawl

Give any AI agent internet access, free and local

  • 109,989 GitHub stars
  • MITLicence MIT

Hermes Agent

Featured

Alternative toGrok Bot

Self-hosted AI agent: persistent memory, multi-channel chat, model choice.

  • 261,524 GitHub stars
  • MITLicence MIT

Elephant Goldfish Model

Alternative toAmazon Kiro

Draft specs with context, review with fresh zero-context agents.

  • 16,479 GitHub stars
  • Apache-2.0Licence Apache-2.0
by category

Open source tools in these categories#

617

Developer Tools

REA (Reverse Engineer Anything), Skills for Real Engineers, superpowers
520

AI & Machine Learning

freeCodeCamp, REA (Reverse Engineer Anything), OpenClaw

Sponsors

Inbox Zero

Alternative toSuperhuman

AI email assistant that drafts replies and clears your inbox

  • 12,942 GitHub stars
  • AGPL-3.0Licence AGPL-3.0
  • #Email

rakazo

Alternative toGrok Bot

AI teammates you own: your keys, your model, your machine.

  • 7,478 GitHub stars
  • Apache-2.0Licence Apache-2.0
  • #AI Agents

SnitchFeed

Live monitoring on LinkedIn, X, Reddit & more. Agentic social listening for startups.

Marketing & Growth

Advertise your product

New open source projects by email

The projects we add and every new guide. Free, unsubscribe any time.

Find open source alternatives to paid software

/
  • Claude Code to OpenCode
  • Jira to Windshift
  • Notion to AppFlowy
  • Slack to Mattermost
  • Linear to GitLab
  • Wispr Flow to Handy
  • Arc to Zen Browser
  • CapCut to Concat
  • Grok Bot to rakazo
  • Superhuman to Inbox Zero
  • Airtable to AITable
  • Muse to OpenClaw
  • Railway to Coolify
  • GitHub Copilot to Cline
  • Datadog to Netdata
  • Confluence to Wiki.js
  • Microsoft Teams to Rocket.Chat
  • 1Password to KeePassXC
  • Firebase to Supabase
  • Pinecone to Qdrant
  • Zapier to n8n
  • Devin AI to OpenHands
  • Asana to Leantime
  • Contentful to Strapi
  • Claude Code to OpenCode
  • Jira to Windshift
  • Notion to AppFlowy
  • Slack to Mattermost
  • Linear to GitLab
  • Wispr Flow to Handy
  • Arc to Zen Browser
  • CapCut to Concat
  • Grok Bot to rakazo
  • Superhuman to Inbox Zero
  • Airtable to AITable
  • Muse to OpenClaw
  • Railway to Coolify
  • GitHub Copilot to Cline
  • Datadog to Netdata
  • Confluence to Wiki.js
  • Microsoft Teams to Rocket.Chat
  • 1Password to KeePassXC
  • Firebase to Supabase
  • Pinecone to Qdrant
  • Zapier to n8n
  • Devin AI to OpenHands
  • Asana to Leantime
  • Contentful to Strapi