Skip to main content
reopt Handbook
reopt Handbook
Developer Unlearning

Why Change

When Expertise Becomes WeightThe Illusion That I Must Write Everything

Design and Implementation Shift

From Up-Front Design to Iterative DesignPrompts Are Design LanguageCode Review in the AI Era

Practice Reset

Testing Strategy ShiftDebugging Habit ResetContext Management: The New Core SkillRedefining Technical Debt

Team and Career

Team Workflow ChangeWhat Not to UnlearnAgentic Transition Strategy

Appendix

Verification ReportUpdate Log
Handbook›Developer Unlearning›Context Management: The New Core Skill
한국어English

Context Management: The New Core Skill

Decide what AI needs to know, what to omit, and when to reset context.

Key takeaways

  • The context window is the AI's working memory: information outside it does not exist, so most "the agent ignored our rule" complaints mean the rule was never in active context.
  • Manage context across three layers with different change frequencies: project (CLAUDE.md, stack), session (current goal, relevant files), and prompt (specific request, constraints).
  • A five-minute session kickoff stating goal, files, rules, constraints, and validation usually beats dumping an entire directory into context.
  • Treat CLAUDE.md as an onboarding document with specific stack and API rules; if a new teammate needs it on day one, the agent does too.
  • When the agent forgets rules or keeps solving the wrong problem, use /compact, summarize decisions, or restart with a clean context package.

The quality of AI coding output depends on prompt quality, and prompt quality depends on context quality. The same model behaves very differently depending on what information it receives.

Context Window as Working Memory

ItemHuman short-term memoryAI context window
CapacitySmall and attention-boundThousands to millions of tokens
ForgettingDistraction and fatigueInformation outside the window does not exist
DegradationTiredness, multitaskingNoise, buried constraints, stale assumptions
SupportNotes and documentationCLAUDE.md, project files, summaries

Core constraint

AI reasons only from the information in context. Many complaints that "the agent ignored our rule" mean the rule was never in the active context.

Context Budget

Observation-based model

This is an explanatory budget model, not a token calculation formula.

Three Context Layers

Project, session, and prompt context layers

Five-Minute Session Kickoff

### Goal
- Fix partial refund behavior in the payment cancellation API and pass tests.

### Current context
- Files: `src/payment/cancel.ts`, `src/payment/cancel.test.ts`
- Rules: money uses Decimal; time is KST.

### Constraints
- Keep existing API response shape.
- Wrap failures in AppError.

### Validation
- Existing tests pass.
- Partial refund rule for 12-24 hours is covered.

This small structure usually beats dumping an entire directory into context.

CLAUDE.md as Onboarding Document

Weak:

- Write clean code.
- Follow SOLID.
- Add tests.

These are generic. Strong project context is specific:

## Stack
- Next.js App Router, React, TypeScript
- PostgreSQL + Prisma
- Auth: session-based JWT

## API rules
- Route Handlers return NextResponse.
- User-facing errors use i18n keys.
- Money is Decimal, not number.

If a new teammate would need to know it on day one, the agent probably needs it too.

Signals of Context Overload

  • The agent forgets a rule agreed earlier.
  • Responses become scattered or inconsistent.
  • It misses explicit instructions in the latest prompt.
  • It changes style without reason.
  • It keeps solving the wrong problem.

When this happens, use /compact, summarize decisions, or start a new session with a clean context package.

64k Output Changes the Old Habit

Large outputs make "split everything into tiny prompts" less necessary. You still need to manage input context carefully, but larger coherent changes can often be requested and reviewed together:

Old habitCurrent strategy
Generate one function at a timeAsk for a module-level change
Split by fileGroup related files for consistency
Ask for code onlyAsk for code, tests, and docs together
Carry a long chat foreverSummarize, compact, or restart deliberately

Next

Read Redefining Technical Debt to understand how AI-readable structure changes maintenance cost.

Related docs

Context Management

Claude Code Complete Guide · Keep Claude Code sessions accurate through memory, compaction, and concise handoffs.

Cmd. /compact

Codex Command Master · Summarize a long conversation to free context.

Cmd. /compact

Claude Code Command Master · Summarize the current conversation to free context.

Mastering CLAUDE.md

Claude Code Complete Guide · Design project memory that Claude Code can actually follow.

Context Injection

Design Systems for the AI Era · Deliver the right design-system context to AI agents at the right time.

Debugging Habit Reset

Move from trace-by-instinct to hypothesis-driven debugging with AI.

Redefining Technical Debt

What became cheaper and what became more expensive in the AI coding era.

On this page

Context Window as Working MemoryContext BudgetThree Context LayersFive-Minute Session KickoffCLAUDE.md as Onboarding DocumentSignals of Context Overload64k Output Changes the Old HabitNext