The Notebook You Found in a Drawer
It was January. You sat down with a fresh notebook -- or a blank Google Doc, or a Notion page with a nice template -- and wrote your goals for the year. You were specific. You were motivated. You wrote down deadlines. You even used bullet points.
By March, you could not find the document. By June, you had forgotten what you wrote. By December, someone asked "did you hit your goals this year?" and you changed the subject.
This is not a willpower problem. It is a systems problem. A plan written in January and never touched again is not a plan. It is a time capsule. You bury it and forget where.
The problem has three parts. First, the plan lives in a single document that you open once and never revisit. Second, there is no mechanism that forces you to look at it again. Third, even if you do look at it, you cannot see how your thinking has changed since January -- because every edit overwrites the previous version.
What if the plan lived in a git repository? What if an AI agent asked you every month what happened, compared your answer to the plan, and told you honestly where you stood? What if you could run git log --oneline plan.md in December and see twelve commits -- one for each month -- showing exactly how your priorities shifted over the year?
That is what you will build today. Not an app. Not a dashboard. A folder of markdown files tracked by git, with a monthly check-in script that talks to an AI. The system is so simple it feels like cheating. But simplicity is why it works -- because the only planning system that matters is the one you actually use.
What You Will Build
By the end of this article, you will have:
- A git repository containing your annual plan as structured markdown files.
- An AI-generated breakdown of your yearly goals into quarterly milestones and monthly targets.
- A monthly check-in workflow where you tell the AI what happened, and it produces an honest assessment plus suggested adjustments.
- A git history that becomes your growth diary -- each commit captures a snapshot of your priorities at that moment in time.
The key insight: the git history IS the reflection tool. git log --oneline plan.md shows you how your priorities shifted over the year. That record of change is more valuable than the plan itself.
Prerequisites
- Claude Code installed and authenticated. If you have not set it up yet, follow the first hour tutorial -- it takes ten minutes.
- Git installed. If you have a Mac, you already have it. If you are on Windows, install Git for Windows.
- Basic terminal comfort. You will type commands and read output. No programming required.
Step 1: Create the Planning Repository
Every good system starts with a container. Yours is a git repository.
mkdir -p ~/annual-plan && cd ~/annual-plan
git init
That is it. A folder with version tracking. Every change you make from this point forward is recorded. Every edit has a timestamp. Every adjustment is recoverable.
Now create the basic structure:
mkdir -p monthly-checkins
touch plan.md goals.md CLAUDE.md
Your repository looks like this:
~/annual-plan/
plan.md -- your master plan (AI will help write this)
goals.md -- raw goals before AI processes them
monthly-checkins/ -- one file per month
CLAUDE.md -- instructions for the AI agent
Three files and a folder. That is the entire system. No frameworks, no templates, no subscriptions.
Step 2: Write Your Raw Goals
Open goals.md and write what you actually want. Do not worry about formatting. Do not worry about being realistic. Just dump everything out. This is the shoebox stage -- you are emptying your brain onto paper.
# What I Want This Year
- Get promoted to senior engineer
- Read 24 books
- Run a half marathon
- Learn enough Japanese to survive a trip to Tokyo
- Ship my side project (that recipe app idea)
- Save $15,000
- Write 12 blog posts
- Get better at public speaking
- Spend less time on my phone
- Cook dinner at home at least 4 nights a week
Do not filter. Do not prioritize. Write everything down, even the goals you suspect are unrealistic. The AI will help you think through feasibility in the next step. Your job right now is honesty, not strategy.
Commit this raw input:
cd ~/annual-plan
git add goals.md
git commit -m "raw goals: brain dump before AI processing"
Your first commit. The git log now has a record of what you wanted before any analysis touched it. In December, you will look back at this commit and see who you were at the start of the year.
Step 3: Configure CLAUDE.md
Before the AI agent works on your plan, it needs instructions. A CLAUDE.md file in your repository acts as a standing order -- like telling a consultant "here is my situation, here are my constraints, here is how I want the output formatted" before the engagement starts.
Write this in CLAUDE.md:
# Annual Planning Agent
## Context
This repository contains a personal annual plan. The owner sets yearly
goals, and this agent helps break them into actionable milestones, run
monthly check-ins, and adjust the plan based on real progress.
## Rules
1. Be honest. If a goal is unrealistic given the time remaining, say so.
2. Never delete goals. Mark abandoned goals as "paused" with a reason.
3. Use simple markdown. No HTML, no complex formatting.
4. When adjusting the plan, explain WHY the adjustment makes sense.
5. Track completion as percentages, not just checkboxes.
6. Always consider dependencies between goals (e.g., "saving money"
and "shipping side project" might conflict on time).
## Plan Structure (plan.md)
- H1: Year title
- H2: Each goal area
- H3: Quarterly milestones
- Each milestone has: target, measurable criteria, dependencies
- Bottom section: "Paused Goals" for anything deprioritized
## Monthly Check-in Format
When reviewing progress, produce:
1. Progress summary (what moved forward)
2. Honest assessment (on track / behind / ahead for each goal)
3. Suggested adjustments (with reasoning)
4. Next month's focus areas (top 3 priorities)
5. One question to prompt reflection
Commit:
git add CLAUDE.md
git commit -m "add AI agent instructions for planning workflow"
Step 4: Let the AI Build Your Plan
This is where the AI earns its keep. You have raw goals. The AI reads them, asks the right questions, and produces a structured plan with quarterly milestones.
cd ~/annual-plan
claude
In the Claude Code prompt:
Read goals.md. Break each goal into quarterly milestones with
measurable targets. Flag any goals that conflict with each other
on time or resources. Write the result to plan.md following the
structure in CLAUDE.md.
The agent reads your goals and thinks through the dependencies. The output in plan.md looks something like this:
# 2026 Annual Plan
## Career: Senior Engineer Promotion
**Target:** Promoted by Q4 performance review
### Q1: Build the case
- Lead one cross-team project (identify by end of January)
- Document 3 technical decisions in team wiki
- Schedule 1:1 with manager to discuss promotion criteria
### Q2: Demonstrate scope
- Ship the cross-team project
- Mentor one junior engineer (weekly 30-min sessions)
- Present at one internal tech talk
### Q3: Fill gaps
- Get feedback from 3 peers on areas to improve
- Take on one project outside comfort zone
- Mid-year review: explicitly ask "what's between me and senior?"
### Q4: Close
- Compile promotion packet (projects, impact, peer feedback)
- Submit by October review cycle deadline
**Dependencies:** Time-intensive. Conflicts with side project if both
peak in Q2. Suggestion: stagger side project to Q3-Q4.
---
## Fitness: Half Marathon
**Target:** Complete a half marathon (any official race, any time)
### Q1: Build base
- Run 3x per week, minimum 3 miles each
- One long run per week, building from 4 to 7 miles
- Register for a race in Q3 or Q4
### Q2: Build distance
- Long run reaches 10 miles by end of Q2
- Add one tempo run per week
- ...
---
## Reading: 24 Books
**Target:** 24 books (2 per month)
### Monthly cadence
- 1 fiction + 1 non-fiction per month
- Track in monthly check-in notes
- If behind pace, audit screen time (see "phone usage" goal)
**Dependencies:** Synergizes with "spend less time on phone" --
replacing scroll time with reading time hits two goals at once.
---
## Paused Goals
(none yet)
Review the output. The AI flagged that your side project and promotion goals compete for the same hours in Q2. It noticed that reading more and using your phone less are natural allies. These connections are hard to see when goals live in separate bullet points.
Edit anything that feels wrong. Then commit:
git add plan.md
git commit -m "structured plan: AI breakdown of yearly goals into quarterly milestones"
Now your repository has three commits. The raw goals, the agent instructions, and the structured plan. The story is already taking shape.
Step 5: The Monthly Check-in
This is the heartbeat of the system. Once a month, you sit down for fifteen minutes and tell the AI what happened.
Create a check-in file:
cat > ~/annual-plan/monthly-checkins/2026-01.md << 'EOF'
# January 2026 Check-in
## What happened this month
- Started the cross-team project (API migration). Going well.
- Read 1 book (Dune). Started second but didn't finish.
- Ran 2x per week, not 3x. Missed some days due to cold weather.
- Signed up for Japanese class on iTalki. Did 3 lessons.
- No progress on side project. Haven't touched it.
- Cooked at home maybe 2 nights per week. Ordering out too much.
## What surprised me
- The API migration is more interesting than I expected. Actually
enjoying the cross-team work.
- Japanese is harder than I thought. 3 lessons felt like nothing.
## What I'm worried about
- Already behind on reading and running. Classic January pattern.
EOF
Now let the AI review it:
cd ~/annual-plan
claude "Read plan.md and monthly-checkins/2026-01.md. Produce an honest progress review following the check-in format in CLAUDE.md. Write the review to the bottom of monthly-checkins/2026-01.md."
The AI reads your plan, reads your notes, and appends an honest assessment:
---
## AI Review: January 2026
### Progress Summary
- **Career:** On track. Cross-team project started, which is the Q1 keystone.
- **Reading:** Behind (1/2 books). Pace needs to double.
- **Fitness:** Behind (2x/week vs 3x target). Weather is a valid reason
but the gap needs closing in February.
- **Japanese:** Started. 3 lessons is a beginning, not a pace.
- **Side project:** Not started. This is fine -- plan says Q3-Q4 focus.
- **Cooking:** Behind (2 nights vs 4 target).
- **Savings:** Not mentioned. How did January go financially?
### Honest Assessment
You are one month in. The career goal is the strongest performer
because it has external structure (a project with deadlines). The
personal goals (reading, running, cooking) are drifting because
nothing forces you to do them. This is the January pattern you
mentioned -- and recognizing it is the first step to breaking it.
### Suggested Adjustments
1. **Running:** Switch to indoor options (gym treadmill, home workout)
for winter months. The "cold weather" excuse will last until March.
2. **Reading:** Set a daily minimum (20 pages) rather than a monthly
target. Monthly targets let you procrastinate for 28 days.
3. **Cooking:** Meal prep on Sundays. Cooking 4 separate dinners is
hard. Cooking once and eating leftovers 3 times is easy.
### Next Month's Top 3
1. Hit 3 runs per week (no excuses -- go indoors if needed)
2. Finish 2 books (carry over the unfinished one + start a new one)
3. Track savings -- you didn't mention finances at all
### Reflection Question
You said the API migration is "more interesting than expected."
Is your career goal just about promotion, or are you discovering
what kind of work you actually want to do?
That reflection question at the end is why this system works. An AI reading your own words back to you, noticing patterns you missed. You said you enjoyed the cross-team work. The AI asked whether your career goal should evolve from "get promoted" to "find work I love." A static plan never asks that question.
Commit the check-in:
cd ~/annual-plan
git add monthly-checkins/2026-01.md
git commit -m "january check-in: career on track, fitness and reading behind pace"
Step 6: The Plan Evolves
After three months of check-ins, your plan is different from January. That is the point.
Maybe you paused the side project because the promotion track absorbed all your energy. Maybe you dropped the half marathon and replaced it with a consistent gym habit. Maybe you discovered that Japanese was a passing interest and redirected those hours to public speaking practice.
Each adjustment gets committed:
cd ~/annual-plan
claude "Read plan.md and all files in monthly-checkins/. Based on Q1 progress, update plan.md: adjust Q2-Q4 milestones, move any goals to 'Paused' if I've stopped working on them, and recalibrate targets. Explain every change."
The AI updates the plan. You review the changes. You commit:
git add plan.md
git commit -m "Q1 review: pause side project, recalibrate fitness to gym habit, add speaking goal"
Step 7: December -- Read the Git Log
This is the payoff. In December, you run:
git log --oneline plan.md
And you see something like:
a3f9c21 Q3 review: promotion submitted, marathon goal back on, 18 books read
8b2e4d7 july: add "speak at meetup" as concrete public speaking target
5c1f0a3 june check-in: side project restarted as weekend-only commitment
e7d3b91 Q2 review: on track for promotion, running consistently, japanese paused
1a4f2c8 april adjustment: replace japanese with public speaking practice
d2e6f9a Q1 review: pause side project, recalibrate fitness to gym habit
b8c3a1e structured plan: AI breakdown of yearly goals into quarterly milestones
f1d5e7b raw goals: brain dump before AI processing
Eight commits. Eight snapshots of who you were at different points in the year. The git log tells a story that no static document ever could.
You can diff any two points:
git diff d2e6f9a..a3f9c21 -- plan.md
That shows you exactly what changed between Q1 and Q3. Which goals survived. Which ones transformed. Which ones you had the honesty to pause.
This is the key insight of the entire system. The plan is not the product. The history of the plan is the product. A plan written in January is a guess. A plan that has been reviewed, adjusted, argued with, and committed twelve times is a record of growth. The git log is your growth diary, and it wrote itself along the way.
Making It a Habit
The system only works if you use it. Here are two ways to make the monthly check-in automatic.
Calendar reminder: Set a recurring event on the first Sunday of every month. Title: "Annual plan check-in (15 min)." When it fires, open your terminal, create the month's check-in file, write what happened, and let the AI review it.
Shell alias: Add this to your .zshrc or .bashrc:
alias checkin='cd ~/annual-plan && code monthly-checkins/$(date +%Y-%m).md'
Now typing checkin opens the current month's file. Write your notes, save, then:
cd ~/annual-plan
claude "Review my latest check-in against the plan. Be honest."
Fifteen minutes a month. That is the cost. The return is a planning system that survives past January, adjusts to reality, and gives you an honest mirror at the end of the year.
Why This Works When Apps Don't
You have tried planning apps. You have tried Notion templates. You have tried habit trackers with streak counts and achievement badges. They all failed for the same reason: they add friction without adding honesty.
A markdown file in a git repo has no friction. You open it in any text editor. You write plain text. You commit. The tool disappears, and only the content remains.
The AI adds the honesty. It reads your January ambitions alongside your March reality and tells you the truth. Not cruel truth -- useful truth. "You're behind on reading because you're spending those hours on career work, which is arguably more important right now. Consider cutting the book target to 18."
And git adds the memory. Every version is preserved. Nothing is lost. In December, you do not have to remember what happened in April. The commit is there. The diff is there. The evolution is there.
Three tools. Markdown for simplicity. AI for honesty. Git for memory. Together, they solve the annual planning problem that willpower alone never could.
The notebook in the drawer was never the problem. The problem was that nobody opened the drawer again until December. Now something does. Every month. And it reads what is inside.