Home/Guides/AI Coding Concepts
AK

Inspired by Andrej Karpathy's take

The New Programmable Layer

A new layer of abstraction has emerged in programming. Understanding these concepts is the difference between being 10X more powerful or falling behind.

"Clearly some powerful alien tool was handed around except it comes with no manual and everyone has to figure out how to hold it and operate it."

The Mental Model: Layers of Abstraction

From your intent to actual execution

1
Your Intent
What you want to achieve
2
Prompts & Context
How you communicate it
3
Agent & Modes
How the AI operates
4
Tools & Permissions
What actions are possible
5
Integrations (MCP, LSP)
Connection to real systems
6
Workflows & Automation
Repeatability at scale
Each layer builds on the one below. Master them from bottom to top.

Concept Explorer

Click any concept to learn what it means and why it matters

Click a concept above to see its explanation

How They Connect: A Day in the Life

1
You type a slash command
/implement login with OAuth
2
This becomes a prompt with context
Your request + current file + project structure
3
An agent activates in a mode
Planning mode first, then execution mode
4
Agent checks permissions
Can I write to src/? Can I install packages?
5
Agent uses tools via MCP
read_file, write_file, run_npm, query_docs
6
LSP provides code intelligence
Find where User type is defined, check for errors
7
Hooks run at key moments
Pre-save: format code. Post-change: run tests
8
Subagents handle subtasks
Research OAuth flows, implement, write tests
9
Memory saves for next time
"This project uses Clerk for auth"
10
Result appears in your IDE
New files created, diff shown, tests passing

The Hard Part: Stochastic Entities

Unlike traditional engineering where 2+2 always equals 4, AI systems are probabilistic. The same input might produce different outputs. This fundamentally changes how we think about software.

Traditional Engineering
  • Deterministic: same input = same output
  • Debuggable: trace exactly what happened
  • Predictable: behavior is specified
  • Testable: assert exact outcomes
AI-Augmented Engineering
  • Stochastic: outputs vary
  • Opaque: "why did it do that?"
  • Emergent: capabilities surprise you
  • Fuzzy: test for "good enough"
The New Skill: Probabilistic Thinking

Success requires building intuition for: When will the AI succeed? When will it fail? How do I detect failures? How do I recover? This is as important as learning the tools themselves.

Quick Reference Card

Copy-paste cheat sheet

THE AI CODING STACK
====================

PROMPTS     = What you tell the AI
CONTEXT     = What the AI can see (files, history, data)
MEMORY      = What persists between sessions

AGENTS      = AI that takes autonomous action
SUBAGENTS   = Agents spawned by agents for subtasks
MODES       = Operational states (plan, execute, safe)

TOOLS       = Individual actions (read_file, run_bash)
PLUGINS     = Bundles of related tools
SKILLS      = Saved prompt+tool combinations

PERMISSIONS = What the AI is allowed to do
HOOKS       = Code that runs at specific moments

MCP         = Model Context Protocol (tool connectivity standard)
LSP         = Language Server Protocol (code intelligence)

SLASH CMD   = Quick actions via /command
WORKFLOWS   = Multi-step automated processes
IDE INT     = AI embedded in your editor

KEY INSIGHT: These are layers, not features.
             Master the foundation before the fancy stuff.

The Path Forward

You don't need to master everything at once. Start with prompts and context. Add tools as you need them. Learn agents when ready for autonomy. The key is to start using these tools today and build intuition through practice.

Claude Code GuideAI Building Blocks