Lesson 1: Stop Coding

Tactical Agentic Coding

The one tactic: Stop coding by hand — your mind and hands are no longer the best tool for writing code, so hand the job to an agentic loop and move up the stack to building systems that build systems.

Overview

AI coding was phase one: the birth of vibe coders and the commoditization of code, built on the "big three" of context, model, and prompt. It let anyone generate hundreds of lines fast, but generating code is not engineering. Engineering is about building systems of leverage that produce valuable outcomes for users and customers.

Phase two is agentic coding, where engineers "strike back" and turn their codebases into increasingly self-operating machines. The mission of Tactical Agentic Coding (TAC) is to make you an irreplaceable engineer — not by working 10x harder, but by finding the leverage points that let 10 minutes of your work equal an hour of someone else's.

The first, most foundational, and most uncomfortable tactic is blunt: stop coding. Powerful language models running long agentic loops on supercomputers are now vastly superior coders. Refusing to let go of hand-typing code is refusing to use the best tool for the job. You still generate and understand code — code is the primary asset that produces features — but you stop typing it. Your cycles go to planning, reviewing, and creating closed-loop structures instead.

This lesson sets the stage for the whole course: understand exactly what changed between AI coding and agentic coding, and why Claude Code makes reliable agentic coding possible at scale for the first time.

Key concepts

Phase one vs. phase two

	Phase 1: AI Coding	Phase 2: Agentic Coding
Primitive	The big three (context, model, prompt)	The core four (adds tools)
Unit of work	Generate code	Execute long chains of tool calls
The engineer	Prompts to generate code	Commands compute; builds systems that build systems
Outcome	Files created	End-to-end engineering work, with or without oversight

The core four

Agentic coding is a superset of AI coding. It expands the big three by adding one new dimension that has been "hiding in plain sight": tools.

Big three:  context + model + prompt
Core four:  context + model + prompt + tools

The new capability is prompts that can reliably execute long chains of tools. Tool calling itself is not new — nearly every modern AI app can web-search, run git, or call MCP tools. What changed is scale and performance: models improved and tools matured enough that a single prompt can drive minutes-to-hours of self-validating work.

The agentic prompt

A plain "prompt" that contains a reliable sequence of tool calls. Wrapped in the right agentic coding tool, the agentic prompt is what runs long, end-to-end developer workflows. This single idea is the bedrock of everything in TAC.

Why Claude Code

Claude Code is the first agentic coding tool to properly combine three essentials:

1. A powerful language model that can reason when needed.
2. The ability to consistently call long chains of tools.
3. The right agent architecture.

Crucially, Claude Code is programmable — it runs in the terminal, so any language with terminal access can fire it off. That lets you embed agents and agentic prompts across the entire software development lifecycle, running with or without your oversight. The tactics are transferable to any tool with the right capabilities; do not get stuck on one tool.

How to apply it

1. Install the essential tools (Claude Code as your primary agentic coding tool, plus an IDE such as VS Code and a terminal).
2. Budget for real token spend — TAC burns millions of tokens. Have the plan or funds to "pay to play" for maximum ROI.
3. Always inspect .claude/settings so you know exactly what your agent is permitted to do.
4. Run an AI coding prompt (generate a file) and an agentic coding prompt (plan, branch, edit, run, commit) side by side to feel the difference between generating code and doing engineering work.
5. Practice invoking Claude Code programmatically from a script (shell, TypeScript/Bun, or Python/uv) so you internalize that it is a building block, not just a chat box.
6. Shift your own time toward planning, reviewing, and building closed-loop structures — not typing code.

Commands & conventions

Convention	Purpose
.claude/	Holds Claude Code permissions/settings for the codebase — always review it
claude	Launch Claude Code interactively in the terminal
claude -p "…"	Programmable mode — run a prompt non-interactively and return the result
programmable scripts	Fire Claude Code from shell, TypeScript + Bun, or Python + Astral uv

# Interactive
claude

# Programmable: fire a one-shot agentic prompt from any script/terminal
claude -p "/your-command"

# Example: run an agentic workflow from a Python single-file script
uv run programmable.py

Key takeaways

• AI coding is not enough — coding is one slice of engineering, not the whole job.
• Stop coding: the agentic loop is now a better coder than you are.
• You still generate and must understand code; you just stop hand-typing it.
• Agentic coding = the big three plus tools = the core four.
• The breakthrough primitive is the agentic prompt: one prompt reliably driving long tool chains.
• Claude Code is programmable — you can embed it anywhere a terminal runs, across the whole SDLC.
• The real goal is building systems that build systems on your behalf.
• To become irreplaceable, you will, paradoxically, replace yourself.

Notable quotes

"In a world where code is a commodity… we do what we always do in technological revolutions. We move up the stack once again."

"Your hands and your mind are no longer the best tool for the job of writing code, full stop."

"Agentic coding is not about us writing code. It's about building systems that build systems on our behalf."

"To become an irreplaceable engineer, you will replace yourself."