2026-02-28|6 min read|--ai-tools--productivity--indie-making--system-design

How I Built a System to Work With AI Across Unlimited Projects

How I Built a System to Work With AI Across Unlimited Projects

I have a problem.

Not the "I have too many ideas" kind of problem that every indie maker jokes about. A real, expensive problem: working with Claude across multiple projects was eating my budget alive.

Each chat would balloon to 115K tokens. I'd explain the same context over and over. Switch between FlashBee and LaKinh? Start from scratch. Token costs piled up. Productivity tanked.

Then I realized something: I wasn't the problem. My workflow was.

## The 115K Token Problem

Picture this: You're deep into coding a feature. 40 messages in, you've got momentum. Then you need to switch to another project.

What do you do?

Most people start a new chat. Explain everything again. "So this is FlashBee, it's a flashcard app for kids..." Another 50 messages. Another 30K tokens.

I was burning through my Claude Pro Max budget on context, not work.

The math was brutal:

  • >Average chat: 115K tokens
  • >Cost per chat: ~$0.35
  • >3 projects active: $1.05/day minimum
  • >Just to maintain context: ~$30/month

And I wasn't even being productive. I was being a human copy-paste machine.

## The Realization

One night, at 2 AM (my best thinking hours), I had a thought:

What if I treated my relationship with Claude like a professional codebase?

Code needs:

  • >Clear documentation
  • >Consistent structure
  • >No repeated explanations
  • >Context that persists

Why wasn't I giving Claude the same?

## The Solution: The Kai System

I created a standardized folder structure. Every project gets the same 5 files:

MyProject/
└── Kai/
    ├── README.md      # What is this project
    ├── QUICK.md       # How to start instantly
    ├── Features.md    # What it does
    ├── Tasks.md       # What needs doing
    └── Progress.md    # What's done

That's it.

But here's the magic: Claude reads these files at the start of every session.

Instead of:

Me: "So FlashBee is a flashcard app..."
Claude: "Tell me more about..."
Me: "It uses Firebase and..."
Claude: "What features does it have?"
(50 messages, 20K tokens)

I now do:

Me: "Continue FlashBee Task 002"
Claude: [reads Kai folder]
Claude: "Task 002 in progress. Ready to continue."
(1 message, 500 tokens)

## The Results

Token savings: 70%

Before:

  • >Session 1: 115K tokens (setup + partial work)
  • >Session 2: 80K tokens (re-explain + more work)
  • >Total: 195K tokens

After:

  • >Session 1: 20K tokens (full Task 001-002)
  • >Session 2: 15K tokens (Task 003-005)
  • >Total: 35K tokens

Same work. 82% less cost.

But the real win wasn't money.

## The Real Win: Mental Bandwidth

Before, every context switch cost me 30 minutes of re-explaining.

Now?

I can jump between 6 active projects seamlessly:

  • >FlashBee (kids flashcards)
  • >LaKinh (Vietnamese astrology)
  • >Hũ Vàng (finance tracker)
  • >Hũ Lì Xì (kids money app)
  • >VocabVault (API business)
  • >Blog (content)

Each takes 1 message to resume.

My brain doesn't hold project context anymore. The Kai folder does.

## The System Rules

I learned these the hard way:

1. One Session = One Goal Don't mix projects. FlashBee session = FlashBee only.

2. Exit Before 50 Messages Long chats = high tokens. Finish the task. Start fresh next time.

3. Be Ruthlessly Concise "Continue Task 002" beats "Hey Claude, I was wondering if we could continue working on Task 002 from yesterday..."

4. Use CLI for Execution Chat for planning. Command-line for doing. Saves 10-20× tokens.

5. End With Summary Every session ends with a summary file. Next session reads it. Zero context lost.

## The Migration Pattern

When I start a new project now:

# 1. Create structure
mkdir MyNewProject/Kai

# 2. Copy templates
cp ~/Kai/templates/* MyNewProject/Kai/

# 3. Fill in project details
# (5 minutes)

# 4. First session
"Init MyNewProject"

Claude reads the Kai folder. We're productive from message 1.

## The Templates

Here's what goes in each file:

README.md: Project overview, tech stack, current status QUICK.md: "Start here" commands, common tasks Features.md: What it does, what it doesn't Tasks.md: Next 5-10 tasks, estimates Progress.md: Session logs, decisions made

Each file is 100-200 lines max. Concise. Scannable.

## The Unexpected Benefits

1. I can onboard contributors (If I ever get any.) They read the Kai folder. They're up to speed.

2. I remember my own decisions "Why did I reject Stripe?" → Check Progress.md → "Oh right, LemonSqueezy has better VN support."

3. I can pause projects for weeks Come back. Read summary. Pick up exactly where I left off.

4. I can scale infinitely 10 projects? 20? Doesn't matter. Each has its Kai folder.

## The Cost-Benefit

Time investment:

  • >Create system: 4 hours
  • >Template each project: 5 minutes
  • >Maintain files: 2 minutes/session

Time saved:

  • >Context switching: 30 min → 1 min (29 min/switch)
  • >Re-explaining: 20 min → 0 min (20 min/session)
  • >Finding old decisions: 10 min → 30 sec

Money saved:

  • >~$20-30/month in token costs

But honestly? The money isn't the point.

## The Real Value

I have zero mental overhead now.

My brain doesn't store:

  • >What Task 002 was about
  • >Why I chose Firebase over Supabase
  • >What the last session accomplished
  • >Which features are done

The Kai folder stores it.

My brain is free to create.

## The Meta-Learning

This system taught me something bigger:

Working with AI isn't about prompting. It's about infrastructure.

Everyone talks about prompt engineering. "Use this magic phrase!" "Add 'think step by step!'"

That's tactics.

This is strategy.

Build the right structure. Let the AI navigate it. Stop being the context layer.

## For You

If you work with Claude (or any AI) across multiple projects:

Try this:

  1. >Create a /Kai folder in your next project
  2. >Add 5 markdown files (templates in the article)
  3. >Next session, tell Claude: "Read the Kai folder first"
  4. >Watch your token usage drop 50%+

It's not about AI getting smarter.

It's about you getting smarter about using AI.

## The Future

I'm iterating this system now:

  • >Auto-generate summaries
  • >Track token usage per project
  • >Integrate with GitHub for automatic docs
  • >Add voice command shortcuts

But the core won't change:

One folder. Five files. Infinite projects.

The templates are in my project files. If you want them, they're MIT licensed. Copy, modify, make them yours.

Token count for this blog post? Written with the Kai system. 3K tokens total. Would've been 15K the old way.

That's the difference.

Now, if you'll excuse me, I have 6 projects to juggle. And thanks to a folder structure, zero context to lose.

—

P.S. Yes, I'm a designer who fell into code. Yes, I built this because I was too lazy to keep explaining things. The best systems come from laziness married to necessity.