The Work You Never See

You think Claude knows your project. Claude is guessing. Every. Single. Session.

Every time you start a session, Claude scans 50 files trying to figure out your stack. React? Vue? TypeScript? Node? Postgres? Who knows. It's making educated guesses — and you never see this happening.

By the time Claude has enough context to help, it's already burned 1,750 tokens. Tomorrow, the session ends. Context gone. Repeat from scratch.

This is the DAAFT cycle. Most developers don't know it exists — because they never see it.

The Invisible Problem

You don't see this happening. But it is.

No CLAUDE.md fixes it. No agent memory fixes it. Files change. Context windows shift. Claude can't stay aligned — so it rediscovers, assumes, and gets it wrong.

Massaged at best. Assumed often. Wrong frequently.

Left unattended, it becomes a silent assassin.

What DAAFT Actually Means

Discover Claude reads 50 files to figure out your stack
Assume Claude guesses React? TypeScript? You never see this.
Ask Claude fills gaps with assumptions — often wrong
Forget Session ends. Context gone. Repeat tomorrow.
Time + Tokens LOST — invisible to you, every single session

Every AI session without persistent context follows this pattern. Claude rediscovers your project structure, makes assumptions you never see, fills gaps with guesses (often wrong), then forgets everything the moment the session ends.

↻ Every session. You never know.

The Math Nobody Wants to See

We asked Claude to calculate the actual cost. Here's what came back:

Without project context (The DAAFT Cycle)

  • Discover project structure: ~500 tokens
  • Ask clarifying questions: ~400 tokens
  • Verify assumptions about stack: ~350 tokens
  • Re-establish conventions: ~300 tokens
  • Context drift corrections: ~200 tokens
Total per session: ~1,750 tokens

With persistent context

  • Load context once: ~150 tokens
  • Zero questions needed
  • Zero assumptions made
  • Zero drift possible
Total: ~150 tokens (once)

The math: 1,750 - 150 = 1,600 tokens saved per session.

That's 91% of your tokens wasted on rediscovery.

91% waste. Every session. Every day. Every project.

But tokens are just the symptom. The real cost is what comes next.

The Real Cost: Time

91% token waste translates directly into time — and you never see it happening.

Every time Claude rediscovers your project, it burns tokens. Every assumption it makes without your knowledge takes you down the wrong path. Every context drift compounds silently across sessions.

We calculated this too:

  • 7 minutes per session Claude working blind
  • 4 sessions per day (conservative)
  • 250 working days per year

7 × 4 × 250 = 7,000 minutes = 116 hours = 2.9 weeks

At industry average ($65/hour):

$5,460
per developer per year

Not tokens. Time. Your time.

For a team of 50 developers, that's $273,000 annually. Add the cost of wrong assumptions cascading into bad code, and you're looking at half a million dollars walking out the door.

For context that should have been established once.

And if you thought that was bad, it's about to get a whole lot worse.

The Cascade Nobody Talks About

DAAFT doesn't just waste tokens and time. It cascades into disaster.

Stage 1: Tokens
91% wasted on rediscovery.
Pure inefficiency.
→
Stage 2: Time
$5,460/year per developer answering the same questions.
Hours you'll never get back.
→
Stage 3: Drift
Small wrong assumptions compound silently across sessions.
Invisible damage.
→
Stage 4: Handicapped
Your project has issues. Your AI assistant is now working ineffectively—even against you.
Crippling.
→
Stage 5: Fail
The project dies. Not from one big mistake, but from a thousand small ones.
Game over.

This is where DAAFT leads. The pain compounds. Then the project fails.

The Reality

70% of software projects fail. Why? Context!
#1 cause: Poor requirements (39%)
#2 cause: Communication breakdown (57%)

Both are context problems.

Your project without .faf? AI starts blind. Every. Single. Time.

With .faf:
100% AI Context — Zero Drift
Success is up to you (and your idea)!

The Question Nobody Asked

Here's what's strange: we've had project configuration files forever.

  • package.json tells npm about your dependencies.
  • tsconfig.json tells TypeScript about your compiler options.
  • .eslintrc tells ESLint about your code style.

But what tells AI about your project?

Nothing. Until now.

Breaking the Cycle

The fix is embarrassingly simple: write down your project context once, in a format AI can read.

project:
  name: "my-app"
  goal: "Real-time dashboard for team metrics"
  main_language: typescript

stack:
  frontend: react
  backend: node
  database: postgres

human_context:
  who: "Engineering team at Acme Corp"
  what: "Internal tool replacing spreadsheet workflows"
  why: "Manual reporting takes 10 hours/week"

That's it. Under 4KB of .faf/YAML. AI reads it once, knows your project forever.

No more discovery. No more assumptions. No more questions. No more drift.

The DAAFT cycle breaks.

What Changes

Be DAAFT

  • 1,750 tokens per session
  • 7 minutes answering questions
  • Assumptions compound
  • Drift accumulates
  • Trust erodes

or FAF

  • 150 tokens once
  • Zero questions
  • Zero assumptions
  • Zero drift
  • Foundation solid

Same AI. Same project. Different outcome.

FAF Foundation 4.0

This approach now has a name and a standard.

.faf — the Foundational AI-context Format — is the first IANA-registered format for persistent AI project context. It's been merged into Anthropic's official MCP registry. Over 21,000 downloads.

Foundation 4.0, shipping now, includes:

  • Bi-sync between project.faf and CLAUDE.md (under 10ms)
  • Status hooks for npm workflows
  • Context-aware skills for commits, PRs, and reviews
  • Scoring system (0-100% AI readiness)

One command to break the cycle:

npm install -g faf-cli faf auto

Your project gets a foundation. Your AI gets context. The DAAFT cycle ends.

The Choice

You can keep answering the same questions every session. Keep watching your AI make wrong assumptions. Keep debugging code that was built on misunderstandings.

Or you can spend 30 seconds creating a project.faf file and never explain your stack again.

Context-drift in 2026?

Don't be DAAFT.

npm install -g faf-cli See the DAAFT Cycle → Learn More