Skip to main content

Context Management

Managing context effectively across AI conversations is crucial for maintaining coherent, productive coding sessions. Learn how to preserve important information, reference previous work, and maintain context in long development sessions.

Why Context Management Matters​

AI models have limited memory within a conversation, and they can lose track of important details as conversations grow longer. Effective context management ensures:

  • Consistency across multiple interactions
  • Efficiency by avoiding repetitive explanations
  • Accuracy in understanding your project's specifics
  • Continuity when working on complex, multi-part tasks

Strategies for Context Management​

1. Context Summarization​

Periodically summarize the current state of your project:

"Context Summary:
- Building a React e-commerce app with TypeScript
- Using Redux Toolkit for state management
- Backend: Node.js with Express and MongoDB
- Current focus: Implementing user authentication
- Completed: User registration, password hashing
- Next: Login functionality with JWT tokens"

2. Reference Previous Work​

Explicitly reference earlier parts of the conversation:

"Using the UserModel interface we defined earlier, create a login service that validates credentials and returns a JWT token."

3. Maintain Project Context​

Keep a running description of your project structure:

"Project Context:
- Frontend: React 18 + TypeScript + Vite
- State: Redux Toolkit + RTK Query
- Styling: Tailwind CSS + Headless UI
- Backend: Express + TypeScript + Prisma
- Database: PostgreSQL
- Auth: JWT + bcrypt
- Testing: Jest + React Testing Library"

Techniques for Long Conversations​

Context Anchoring​

Start new topics by anchoring to established context:

"In our e-commerce app (React + TypeScript + Redux), we need to add shopping cart functionality. The cart should integrate with our existing user authentication system."

Progressive Context Building​

Build context incrementally as you work:

Session 1: "Create a basic React component structure"
Session 2: "Add TypeScript types to the component we created"
Session 3: "Add Redux integration to our typed component"
Session 4: "Add unit tests for our Redux-connected component"

Context Checkpoints​

Regularly create checkpoints to summarize progress:

"Checkpoint - What we've accomplished:
1. ✅ User authentication system (registration, login, JWT)
2. ✅ Product catalog with search and filtering
3. ✅ Shopping cart with add/remove functionality
4. 🔄 Currently working on: Checkout process
5. ⏳ Next: Payment integration"

Managing Project Context​

File Structure Context​

Provide your project structure when relevant:

"Current project structure:
src/
├── components/
│   ├── auth/
│   │   ├── LoginForm.tsx
│   │   └── RegisterForm.tsx
│   ├── products/
│   │   ├── ProductCard.tsx
│   │   └── ProductList.tsx
│   └── cart/
│       ├── CartItem.tsx
│       └── CartSummary.tsx
├── hooks/
│   ├── useAuth.ts
│   └── useCart.ts
├── services/
│   ├── api.ts
│   └── auth.ts
└── types/
    ├── user.ts
    └── product.ts

Working on: Adding order management to the cart/ directory"

Code Context​

Reference specific code patterns or conventions:

"Following our established pattern (like in ProductCard.tsx), create a OrderItem component that:
- Uses the same TypeScript interface pattern
- Follows our error handling convention with try/catch
- Implements the same loading state pattern with isLoading boolean"

Dependencies Context​

Mention relevant dependencies and versions:

"Using our current stack:
- React 18.2.0
- TypeScript 5.0
- @reduxjs/toolkit 1.9.5
- react-router-dom 6.11.0

Create routing for the new order management pages."

Context Persistence Techniques​

External Context Files​

Maintain context in external files:

project-context.md:

# Project Context

## Tech Stack
- Frontend: React 18 + TypeScript + Vite
- State: Redux Toolkit
- Routing: React Router v6
- Styling: Tailwind CSS

## Current Architecture
- Components follow atomic design principles
- Services handle API calls
- Custom hooks manage component logic
- Types are centralized in types/ directory

## Coding Conventions
- Use functional components with hooks
- Prefer TypeScript interfaces over types
- Error boundaries for component error handling
- Custom hooks for reusable logic

Plan and Task Files​

Use structured planning files:

plan.md:

# Development Plan

## Phase 1: Authentication ✅
- [x] User registration
- [x] Login/logout
- [x] JWT token management
- [x] Protected routes

## Phase 2: Product Management 🔄
- [x] Product listing
- [x] Product search
- [ ] Product filtering
- [ ] Product details page

## Phase 3: Shopping Cart ⏳
- [ ] Add to cart
- [ ] Cart management
- [ ] Checkout process

task.md:

# Current Task: Product Filtering

## Requirements
- Filter by category, price range, brand
- URL-based filtering for bookmarkable results
- Combine with existing search functionality
- Responsive design for mobile

## Implementation Notes
- Use URLSearchParams for query management
- Integrate with existing Redux product slice
- Add filter UI components to ProductList
- Update API service to handle filter parameters

Context Handoff Between Sessions​

Session Summaries​

End sessions with summaries:

"Session Summary:
- Implemented user authentication with JWT
- Created protected route wrapper component
- Added login/logout functionality to navbar
- Next session: Start shopping cart implementation
- Files modified: auth.service.ts, ProtectedRoute.tsx, Navbar.tsx"

Session Startup​

Begin new sessions by reviewing context:

"Continuing from last session where we implemented user authentication. Now starting shopping cart functionality. Current project uses React + TypeScript + Redux. Need to create cart slice and cart components."

Common Context Management Mistakes​

Information Overload​

Avoid:

"Here's everything about my project: [massive dump of all project details]"

Instead:

"Context for this task: Building a React e-commerce app. Currently working on shopping cart. Using Redux for state management."

Assuming Persistence​

Avoid:

"Use the same approach as before"

Instead:

"Use the same error handling pattern we established in the LoginForm component (try/catch with toast notifications)"

Inconsistent Context​

Avoid: Changing project details mid-conversation without explanation.

Instead:

"Update: We've decided to switch from Redux to Zustand for state management. Please adjust the cart implementation accordingly."

Tools for Context Management​

Documentation Tools​

  • Notion: Project wikis and context documents
  • Obsidian: Linked note-taking for project context
  • GitHub Wiki: Version-controlled project documentation

Code Organization​

  • README files: Project overview and setup instructions
  • ARCHITECTURE.md: System design and patterns
  • CONTRIBUTING.md: Development guidelines and conventions

AI-Specific Tools​

  • Context files: Dedicated files for AI context
  • Prompt templates: Reusable prompt structures
  • Session logs: Record of AI interactions and decisions
info

Good context management is like good documentation – it helps both you and the AI understand the project better and work more effectively together.

Best Practices​

  1. Start with essential context – Don't overwhelm with details
  2. Update context as you progress – Keep information current
  3. Reference specific examples – Point to concrete implementations
  4. Use consistent terminology – Maintain the same vocabulary throughout
  5. Create context checkpoints – Regularly summarize progress
  6. Document decisions – Record why certain approaches were chosen

Next Steps​