How to Manage Complex Development Tasks with planning-with-files Skill

Mar 25, 2026

I was in the middle of implementing a complex authentication system when my Claude Code session crashed. After restarting, I ran /clear to start fresh, and just like that - all context was gone. No memory of what I’d completed, what was left to do, or what issues I’d discovered along the way.

That’s when I realized I needed a better way to manage complex, multi-step development tasks.

The Problem with Long Development Sessions

Complex development work often spans multiple sessions. You might be implementing a feature that requires:

Database schema changes
Multiple API endpoints
Security considerations
Testing infrastructure

When you’re working through this incrementally, you need to track:

What you’ve completed
What’s in progress
What issues you’ve found
What’s left to do

I tried keeping notes in a separate document, but I’d forget to update them. Or I’d write notes that Claude couldn’t read back. The context was always fragmented.

Finding the Solution

I discovered the planning-with-files skill - a Claude Code skill that automatically creates and maintains plan files that persist across sessions.

# Installation
npx skills add planning-with-files -y -g

The -g flag installs it globally, so it’s available in all your projects.

How It Works

When you give Claude a complex task, the skill creates three files:

task_plan.md - The breakdown of all steps and phases
progress.md - Current status and what’s been completed
findings.md - Issues discovered and decisions made

Let’s see it in action. I asked Claude:

“Plan and track the implementation of a user authentication system with JWT tokens, password reset, and rate limiting”

Claude created a structured plan:

## Phase 1: Database Schema
- [ ] Users table with email/password
- [ ] Sessions table
- [ ] Password reset tokens table

## Phase 2: API Endpoints
- [ ] POST /auth/register
- [ ] POST /auth/login
- [ ] POST /auth/logout
- [ ] POST /auth/reset-password

## Phase 3: Security
- [ ] Rate limiting middleware
- [ ] Input validation
- [ ] Token refresh logic

As I worked through each phase, Claude updated progress.md:

# Progress Tracking

## Completed
- [x] Users table with email/password
- [x] Sessions table
- [x] Password reset tokens table
- [x] POST /auth/register
- [x] POST /auth/login

## In Progress
- [ ] POST /auth/logout (50% - endpoint created, testing)

## Not Started
- [ ] POST /auth/reset-password
- [ ] Rate limiting middleware
- [ ] Input validation
- [ ] Token refresh logic

## Last Updated: 2026-03-25 10:15:00

The Session Recovery Magic

Here’s the real power. After a session crash or /clear, I can just say:

“Continue working on the authentication system”

Claude reads the plan files and picks up exactly where it left off. No re-explaining the entire context. No guessing what’s done.

I tested this by intentionally clearing my session mid-task. Claude:

Read task_plan.md to understand the full scope
Read progress.md to see what was completed
Read findings.md to understand discovered issues
Continued with the next incomplete task

Common Mistakes I Made

Not Updating Progress

The skill doesn’t automatically update - you need to ask Claude to update the progress file after completing work:

"I've completed the logout endpoint. Update progress.md and continue with the next task."

Storing Files in Temp Locations

I initially stored plan files in /tmp. Bad idea - they got deleted on restart. Store them in your project directory.

Over-Planning Simple Tasks

This skill is for genuinely complex work. For a simple bug fix or documentation update, it’s overkill. I now reserve it for tasks that will span multiple sessions or involve 10+ steps.

When to Use It

I find this skill essential for:

Feature implementations with multiple components
Refactoring projects that touch many files
Migration tasks with sequential dependencies
Research tasks where I need to track findings

It’s less useful for:

Quick bug fixes
Single-file changes
Documentation updates
Simple configuration changes

Real Example: API Migration

I recently used this for migrating a REST API to GraphQL:

## Phase 1: Schema Design
- [ ] Define GraphQL types from REST models
- [ ] Set up Apollo Server
- [ ] Configure context and authentication

## Phase 2: Query Resolvers
- [ ] User queries
- [ ] Product queries
- [ ] Order queries with pagination

## Phase 3: Mutation Resolvers
- [ ] Create/Update/Delete user mutations
- [ ] Order processing mutations
- [ ] Inventory update mutations

## Phase 4: Migration Strategy
- [ ] Create GraphQL endpoint alongside REST
- [ ] Gradual client migration
- [ ] Deprecation timeline

This project took two weeks across multiple sessions. Without the planning files, I would have lost context repeatedly.

Key Takeaways

Install globally - npx skills add planning-with-files -y -g
Ask Claude to update progress - The skill tracks, but you need to trigger updates
Store in project directory - Not temp locations
Use for genuinely complex tasks - Not simple fixes
Session recovery is automatic - Just say “continue” after /clear

The planning-with-files skill has become my go-to tool for any development task that can’t be completed in a single sitting. It’s like having a project manager that remembers everything and costs nothing.

Final Words + More Resources

My intention with this article was to help others share my knowledge and experience. If you want to contact me, you can contact by email: Email me

Here are also the most important links from this article along with some further resources that will help you in this scope:

👨‍💻 Claude Code Skills
👨‍💻 planning-with-files GitHub

Oh, and if you found these resources useful, don’t forget to support me by starring the repo on GitHub!