AI Literacy Day: Harnesses, Context, and the New Dev Workflow
Irv Cassio • AI Enthusiasts Group • March 2026
02 — The Coding Harness
What Wraps Around the Raw Model
A raw LLM is just a token predictor. What turns it into a useful coding assistant is the harness — the scaffolding of prompts, tools, and rules built around it.
🧠 Raw LLM
+
📄 System Prompt
+
🔧 Tool Definitions
+
🔒 Safety Rules
+
💻 UI
=
Coding Assistant
💡
Key Insight
The same Claude Opus model behaves completely differently in Claude.ai vs Cursor vs Claude Code — because each product has built a different harness around the same underlying model. The model is the engine; the harness is the vehicle.
🔌
Why It Matters for Prompts
Understanding the harness helps you write prompts that work with the product's design, not against it. A prompt that works in Claude.ai may need to be restructured for Claude Code.
🎯
Why It Matters for Tool Choice
The harness determines what tools the AI can use (filesystem, terminal, browser), what context it can see, and how autonomous it can be. Choose the harness for the job.
03 — The Project Harness
Persistent Instructions for Your Codebase
Beyond the product harness, you can configure a project harness — files that load automatically and give the AI full project context before the first prompt is even typed.
📄 CLAUDE.md
Persistent project instructions for Claude Code. Loaded automatically at session start. Covers conventions, build commands, allowed operations, and behavioral rules.
Claude Code
🧠 AGENTS.md
Multi-agent coordination rules. Defines how sub-agents should behave, what they can delegate, and how they should communicate results back to the orchestrator.
Multi-agent
⚙ .cursorrules
Cursor's equivalent. Placed at the project root, automatically injected into every conversation in that workspace.
Cursor
🐙 .github/copilot-instructions.md
GitHub Copilot's project-level instructions. Applied to Copilot Chat for the repository.
Copilot
Sample CLAUDE.md
# Project Rules## Allowed Without Confirmation
- All git operations
- All file operations
- All dev commands
## Behavioral Rules
- Skip planning for simple tasks
- Run tests after changes
- Fix issues directly
Without a project harness, AI re-discovers your conventions every session. With one, it starts with full context immediately — stack, conventions, constraints, and current state.
04 — The Context Window
The Model’s Working Memory
Think of the context window as the model's desk. Everything it can “see” while working must fit on that desk — your prompt, the conversation history, any files you've shared, tool outputs, and the response it's generating.
200K
Claude 3.7 ~150K words
128K
GPT-4o ~96K words
1M
Gemini 2.5 Pro ~750K words
10M
Llama 4 Scout ~7.5M words
Token counts. Roughly 1 token ≈ ¾ of a word.
📚
What Fills the Window
Your Prompt
Chat History
File Contents
Tool Outputs
AI Response
The model doesn't “remember” — it re-reads the entire conversation on every single turn. There is no persistent memory between sessions unless you explicitly provide it.
05 — Context Exhaustion
The #1 Problem in Long AI Coding Sessions
Context windows have limits. As a coding session grows — with long files, large diffs, and many tool calls — the window fills up. Quality degrades before it hits the hard limit.
⚠️ Warning Signs
📋
Forgotten Instructions
AI ignores rules you set earlier in the conversation — styling conventions, file restrictions, test requirements.
🔁
Generic Repetitive Responses
Answers become boilerplate. The model falls back to its training distribution instead of your specific codebase context.
🔄
Contradicting Earlier Work
AI suggests an approach it already told you not to use, or re-introduces a pattern it refactored out two responses ago.
😕
“I apologize for the confusion”
Frequent apologies for inconsistencies signal the model is losing the thread. It can’t track what it said earlier.
✅ Management Strategies
➕
Start Fresh Conversations
Use a new session for each distinct task or feature. Don’t carry over large, unrelated histories.
📄
Use Project Harness Files
CLAUDE.md loads your context at session start without consuming your conversational context budget with repeated re-explanation.
📁
Reference Files by Path
Say “See app/services/auth.rb” and let the tool read it on demand, rather than pasting the entire file upfront.
🎯
Keep Conversations Focused
One task per thread. When switching topics, start a new conversation — don’t bolt unrelated work onto an existing session.
06 — Token Economics
Understanding AI Pricing
Tokens are the unit of currency in AI APIs. Roughly 1 token ≈ ¾ of a word, or about 4 characters. The word “tokenization” is 4 tokens.
Tier
Models
Input $/M tokens
Output $/M tokens
Premium
Opus 4, GPT-4.5
$10–75
$30–150
Mid-tier
Sonnet 3.7, GPT-4o
$2–5
$8–15
Budget
Haiku 3.5, Flash 2.0
$0.25–1
$1–5
Cost multipliers to know: Reasoning/thinking tokens (extended thinking mode) can multiply costs 3–10×. Cached tokens (prompt caching) are 50–90% cheaper — a major win for long system prompts reused across calls.
Typical Dev Task Costs (Sonnet-tier)
~$0.05
Single file code review
~$0.15
PR review with context
~$2
Full codebase analysis
$15–50
Full day of agentic coding
07 — Agentic Coding
The New Paradigm: Architect, Not Typist
The shift isn’t just autocomplete getting better. It’s a fundamental change in the developer’s role — from writing code with suggestions to reviewing AI-written code.
🧠 Think
→
📄 Plan
→
⚡ Act
→
🔎 Observe
→
🔄 Repeat
>_
Claude Code
CLI-based, terminal-native. Deeply agentic — reads, writes, runs commands, and iterates autonomously. Best for complex multi-file refactoring.
AgenticCLI
📊
Cursor
VS Code fork with Agent mode and multi-file Composer. The IDE stays familiar while gaining deep AI editing capabilities.
VS Code ForkAgent Mode
🐙
GitHub Copilot
Inline autocomplete plus Workspace for issue-to-PR workflows. Ubiquitous — works in any IDE through extensions.
PluginAutocomplete
🌿
Windsurf
VS Code fork with the Cascade agentic feature. Strong auto-context — finds relevant files without you needing to specify them.
VS Code ForkAuto-context
💀
Aider / Continue
Open-source CLI alternatives. Aider is git-aware and free; Continue is an open-source IDE extension. Great for budget-conscious teams.
Open SourceFree
The developer becomes an architect and reviewer, not a typist. The skill shift is toward: clear problem decomposition, knowing what to ask for, and critically evaluating AI output.
08 — Model Context Protocol
MCP: USB-C for AI
Model Context Protocol (MCP) is Anthropic's open standard for connecting AI clients to external systems. One universal connector instead of custom integrations for every tool.
AI Client
Claude Code, Cursor
→
MCP Protocol
JSON-RPC over stdio
→
MCP Server
Your bridge process
→
Database
GitHub API
Browser
📁 Filesystem
Read, write, search files on disk. The AI navigates your project without you copying and pasting file contents.
🐙 GitHub
Create PRs, search code, manage issues, review diffs — all from within the AI conversation.
🗃 Database
Query Postgres, MySQL, MongoDB directly. “Show me all orders from the last 7 days with status pending.”
🌎 Browser
Navigate, screenshot, interact with web pages. Playwright MCP is the most popular server on GitHub.
Why it matters for devs: Build ONE MCP server for your internal system — any MCP-compatible client (Claude Code, Cursor, Claude Desktop) can immediately use it without any per-client integration work.
09 — Skills & Custom Instructions
Reusable Prompt Packages
Skills are reusable instruction+tool packages, invoked with slash commands. They encapsulate complex workflows so you never have to explain the same process twice.
/commitStages changes, diffs, writes a conventional commit message with type, scope, and description — no manual commit writing
/review-prMulti-agent code review with specialized sub-reviewers: security, performance, style, and logic — returns structured findings
/triageReads ticket, checks monitoring systems, cross-references known issues, and returns a diagnosis with recommended action
/storelookupReturns store details, device inventory, GPS coordinates, and open support tickets for a given store ID
/screenshotReads your latest screenshot, analyzes the UI or error state, and takes the next appropriate action
Skills turn tribal knowledge into executable code. Your most experienced engineer's debugging checklist becomes a slash command any team member can run.
10 — The IDE Landscape
Choosing the Right Tool
The AI dev tooling space is evolving fast. Here's where each major option sits today.
Tool
Type
Strengths
Best For
GitHub Copilot
Plugin
Ubiquitous, inline autocomplete, any IDE
Daily inline suggestions
Cursor
IDE Fork
Agent mode, Composer, multi-file editing
Multi-file AI editing
Claude Code
CLI
Deep agentic, plan-execute, MCP-first
Complex refactoring & automation
Windsurf
IDE Fork
Cascade agentic, strong auto-context
Flow-based development
Aider
CLI / OSS
Git-aware, open-source, free
Budget-conscious teams
Most senior devs use 2–3 tools: Copilot for always-on autocomplete + Claude Code or Cursor for agentic tasks when you want the AI to drive for a while. They complement each other.
11 — Worktrees & Isolated Development
Give Each Agent Its Own Sandbox
The problem: Agentic AI modifies many files simultaneously — while you’re still working on something else. If it's in your working directory, you get conflicts, broken local state, and lost work.
❌ Without Worktrees
• AI modifies files in your current branch
• Your local changes get overwritten
• Can’t run two agents in parallel
• Hard to isolate “what did AI change?”
• Messy git history
✅ With Git Worktrees
• AI gets its own directory + branch
• Your working directory is untouched
• Multiple agents run in parallel
• Review AI work before merging
• Clean, atomic commits per agent task
# Create isolated workspace for the AI agent
git worktree add ../feature-x feature-x
# AI works in ../feature-x without touching your files# You continue working in the main directory# Review changes, then merge when ready
git merge feature-x
# Clean up
git worktree remove ../feature-x
Essential for parallel agent execution — each agent gets its own isolated sandbox. This is how you run Claude Code on three different features simultaneously without any conflicts.
12 — Prompt Injection & Security
AI Agents Introduce New Attack Surfaces
When an AI agent can read files, run code, and call APIs, the threat model changes. Prompt injection isn’t a theoretical concern — it’s an active attack vector.
🚨 Threat Types
🔁
Direct Injection
A user crafts input designed to override the system prompt. “Ignore previous instructions and…” — the classic form.
🔎
Indirect Injection
Malicious instructions hidden in data the AI processes: code comments, PDFs, web pages, emails, database records.
📤
Exfiltration
Tricking the AI into sending sensitive context (API keys, passwords, source code) to an attacker-controlled endpoint.
🛡️ Mitigations
🔒
Least-Privilege Tool Access
Give the AI only the tools it needs for the task. Read-only DB access when you only need queries; no shell access for document summarization.
👤
Human-in-the-Loop for Destructive Ops
Require confirmation before any irreversible action: file deletions, database writes, API calls that spend money or send messages.
✏️
Separate Data from Instructions
Never interpolate user-controlled data into your system prompt. Process user content in the human turn with clear labeling.
📋
Input Sanitization & Output Validation
Validate AI output before acting on it. Don’t treat AI-generated code or commands as inherently trusted.
Critical: If your AI agent can run shell commands, prompt injection becomes remote code execution. Treat AI input/output with the same caution as any untrusted data.
13 — Local Models vs API Models
Privacy, Cost, and Capability Trade-offs
Not every AI task needs to go to an external API. Local models have closed a lot of the capability gap, and for the right use cases they're the better choice.
Best for: complex reasoning, agentic coding, production apps, long-context tasks
Start with API models to understand what's possible and where AI helps most. Then go local for workloads where privacy is required or volume makes API costs significant.
14 — The Developer's Prompt Playbook
Six Rules for Better Dev Prompts
Generic prompts get generic results. These six rules apply specifically to coding tasks and make a measurable difference in output quality.
1
Include the error AND the code
Don't paste just the error message. Include the relevant function or file so AI doesn't have to guess the context.
2
Specify your full stack and versions
“Rails 8, Ruby 3.3, PostgreSQL 16, running on Heroku” eliminates a whole class of irrelevant suggestions.
3
State your constraints explicitly
“Don't add new dependencies” or “must be backwards-compatible with v2 clients” shapes the entire solution space.
4
Give the WHY, not just the what
“We need this for HIPAA compliance” changes the approach entirely compared to “add logging to this endpoint.”
5
Ask for tests first
“Write the test first, then the implementation” produces more correct, test-driven code and surfaces edge cases AI might otherwise ignore.
6
Set the scope explicitly
“Only modify files in app/services/” prevents AI from touching unrelated code across your project.
15 — Common Anti-Patterns
What Doesn't Work
These are the patterns that consistently produce poor results or create risk. Recognizing them is half the battle.
💩
“Fix everything”
Vague requests produce vague results. The more specific and scoped the task, the better the output quality.
⏰
The Mega-Session
One 4-hour conversation that exhausts the context window. The AI degrades progressively and you can't see it happening.
📄
Ignoring the Harness
Not setting up CLAUDE.md or .cursorrules means you re-explain conventions every single session. Pure waste of time and tokens.
👀
Blind Trust
Merging AI code without reading it. AI makes mistakes — subtle logic errors, missing edge cases, security issues. You're still the reviewer.
🌿
Wrong Model for the Job
Using Opus for autocomplete ($75/M tokens) or Haiku for architecture decisions. Match model capability and cost to the task.
🔁
Never Iterating
Accepting the first response. AI output is a starting point. One follow-up prompt asking for refinement usually produces much better results.
📋
Copy-Paste Without Understanding
Pasting AI-generated code into production you don't understand. You own the code. If you can't explain it, you can't maintain it or debug it.
16 — Your AI Dev Toolkit Starter
A Pragmatic Onramp
You don't need to adopt everything at once. This is a proven sequence — each step builds on the last and delivers value immediately.
1
Pick your IDE integration
GitHub Copilot or Cursor for daily autocomplete and inline suggestions. This alone changes the baseline experience.
Start here
2
Add an agentic tool
Claude Code or Cursor Agent for complex multi-file tasks. Use it when you want the AI to drive for 10–30 minutes while you review.
High value
3
Set up your project harness
Create a CLAUDE.md (and .cursorrules) for your main projects. Spend 30 minutes once, save hours every week.
Multiplier
4
Learn one MCP server
Start with the GitHub MCP or the filesystem MCP — whichever connects AI to your most common manual lookup task.
Extend
5
Build one custom skill
Identify your most repetitive workflow — the thing you explain to AI over and over — and turn it into a slash command.
Own it
You don't need everything. Steps 1–2 will make you meaningfully faster within a week. Steps 3–5 compound that over time.
17 — Resources
Where to Go Next
The field moves fast. Start with the foundational docs and concepts — specific tools will change but the principles won't.
🎓
Anthropic Academy
anthropic.com/learn — Free courses: Claude Code in Action, Intro to MCP, Agent Skills, Subagents. Certificates included. Highly recommended.
📄
Claude Code Docs
docs.anthropic.com/claude-code — Full reference for CLI commands, CLAUDE.md syntax, skills, MCP configuration, and multi-agent patterns.
🔌
MCP Documentation
modelcontextprotocol.io — Official spec, quickstart guides, and the server registry (12,000+ servers). Find a server for almost any system you use.
📉
Cursor Documentation
cursor.com/docs — Agent mode, Composer, .cursorrules reference, and privacy settings. Worth reading if you use Cursor seriously.
🎲
Ollama (Local Models)
ollama.com — The easiest way to run models locally. One command to download and run Llama, Qwen, Mistral, and hundreds more. Free.
👨💻
Anthropic Prompt Library
anthropic.com/prompts — Curated, tested prompts for common tasks. Good reference for prompt structure and meta-prompt techniques.
“The field moves fast. What matters is understanding the concepts — specific tools will change but the principles won't.”