THE AI-AUGMENTED
ENGINEERING TEAM
How engineers + Claude Code turn any codebase — even legacy spaghetti — into an unfair advantage.
PRESS → OR SPACE TO BEGIN
What is AI — the 70-year shift
Artificial Intelligence
The umbrella: software doing tasks that need human-like intelligence — language, patterns, decisions.
Example: a spam filter deciding which email is junk.
Machine Learning
Don't write rules — show the machine examples, and it learns the rules itself.
Example: Netflix learning what you like — or predicting which patients will miss appointments.
Deep Learning
Machine learning with massive layered neural networks — loosely inspired by the brain.
Example: your phone unlocking by recognizing your face, or imaging software flagging a tumor on an X-ray.
Generative AI
Models that create — text, code, images. Claude, GPT, Copilot live here.
Example: "write me a leave application" — a finished draft in 5 seconds.
🕹️ The old way — tell it HOW
Need to find every invalid phone number in 500 files? Write the code yourself: loops, regex, edge cases, testing. Half a day, if nothing surprises you.
✨ The new way — tell it WHAT
"Find all invalid phone numbers in these files and export them to a CSV." The AI writes and runs the code itself. A few minutes, and you read the diff.
For 70 years we told computers HOW. Now we describe WHAT — and they figure out how.
🧭 The AI terms you'll actually hear
Generative AI
Models that create content on request — text, code, images. ChatGPT, Claude chat, image generators.
Like a consultant: gives you answers, you do the work.
AI Agents
AI + tools: it can read files, run commands, execute tests, query databases — and actually complete the task. Claude Code, and OpenAI's Codex.
Like a contractor: takes the job, delivers the result.
Agentic AI
The working loop that makes agents reliable: plan → act → observe → self-correct — repeated until the job is done, like an engineer debugging.
This loop is what changed in the last two years.
Other terms you may hear: Narrow AI (every AI that exists today, great at specific tasks), AGI (human-level at everything — doesn't exist yet), ASI (beyond human — theoretical). What matters here: Claude Code is an agent, not a chatbot.
🎯 Why Claude Code fits your team
It handles old, messy code
Most AI tools do well on small, clean projects. This one is built for the opposite: big codebases, written years ago, that nobody fully remembers. That's the code you actually work on.
It finishes the job, not just a line
You describe the problem in plain words. It finds the right files, makes the changes, runs the build, reads the errors, and fixes them — while you watch.
It shows its plan first
For anything tricky, it writes out what it intends to do and waits for your yes. You spot a bad idea in ten seconds — instead of after 500 lines of wrong code.
Your code stays yours
On business plans your code and prompts are not used to train the model, and your admin controls access. On individual plans that's a setting you own — check it before the first repo goes in. (More on the red lines later.)
Autocomplete tools help you type faster. This one takes whole tasks off your plate. That's the difference worth paying for.
🖥️ This is what working with it feels like
⏱️ Where the hours come back from
Bug hunting
Paste the stack trace or ticket. It traces controller → service → stored proc and proposes the fix, explained.
Code archaeology
"What does this 900-line BillingController do?" Accurate walkthroughs of code nobody remembers writing.
Test generation
Unit + integration tests with edge cases you'd forget. Your best defence against breaking something old.
SQL surgery
Explains, optimizes and reviews stored procedures. Flags missing indexes, injection risks, N+1 patterns.
First-pass review
Every PR reviewed by AI for bugs, security and standards — before any human spends a minute on it.
Docs & tickets
Release notes, API docs, commit messages, Jira descriptions — generated from the actual diff, in seconds.
Rule of thumb: any task where you sigh "this will take an hour of tedium" — delegate it first, judge the result after.
🍝 Taming legacy code — the proven sequence
"Taming" = making old code safe to change: first understand it, then protect it with tests, then improve it step by step — while it keeps running in production.
⚠️ Anti-pattern: "Claude, rewrite the whole thing in .NET 10." Case study — a hospital HMIS: a running system's greatest asset is that it runs. Surgeons, not demolition crews.
💡 Why AI changes the math: docs + characterization tests were always step one — just too expensive. Now they cost days, not quarters.
🧩 Skills · Projects · Agents
Skills = recipes
A written "how-to" that Claude loads by itself when the task matches (SKILL.md).
How to use it: take a job your team already does the same way every time — release notes, SQL review — and write the steps down once in .claude/skills/.
Payoff: nobody explains the method again, and it loads only when it's relevant — costing tokens where it helps and nothing elsewhere.
Projects = the library
A shared workspace in Claude chat: upload specs, standards and client docs once, and every conversation there already knows them.
How to use it: one Project per product or client. Put the documents in, then ask questions inside it instead of pasting files into chat.
Payoff: the same 20-page spec stops being re-pasted into twenty conversations — the biggest source of wasted tokens on most teams.
Agents = the chef
The workers that actually do things: take a goal, use tools, keep going until it's done.
How to use it: give the main agent the task, and hand the big searches to a subagent in .claude/agents/ — a sql-reviewer, an hl7-expert.
Payoff: the subagent reads 40 files in its own window and hands back ten lines. Your session stays short, which keeps it sharper and cheaper.
Recipe 📖 · Library 🏛️ · Chef 👨🍳. Used together these aren't just tidiness — they cut the re-explaining, keep each session short, and get noticeably more work out of the same monthly plan.
📜 CLAUDE.md — the repo's constitution HIGHEST ROI
A markdown file at repo root, read by Claude every session. Persistent memory: conventions, commands, danger zones. Written once — applied to every task, by every engineer, forever.
- Lean: rules, not essays. Every line costs tokens every session.
- Maintained like code: PR it; when Claude repeats a mistake, add a rule.
- Nested: a per-module CLAUDE.md inside
/Billingfor billing-only rules.
🧭 Habits that get the best out of it
Say what, and say where
Name the file or the module. "Fix the pharmacy bug" makes it guess; "negative quantities in the stock report after an expiry write-off, probably in PharmacyReportService" makes it work.
Ask for the plan first
For anything bigger than a one-liner, ask what it intends to do before it does it. Turning down a bad plan takes ten seconds. Undoing bad code takes an afternoon.
One job per session
Start fresh when you move to something unrelated. Leftover context from the last task is dead weight it re-reads on every single turn.
Make it prove it
Ask it to run the build and the tests, not just write the code. "It compiles and the tests pass" is worth a great deal more than "this looks right".
Fix the rule, not the symptom
When it makes the same mistake twice, don't correct it twice — add a line to CLAUDE.md so it stops making it at all.
Read what you merge
Treat it like a colleague's pull request. Ask about anything you don't follow — it will explain its own work as many times as you need.
Four smaller ones: point at files rather than pasting them in · batch related fixes into one go · hand the big searches to a subagent · don't open a session to rename a variable. All of it keeps the session short — which is what decides whether your plan lasts the month.
⚡ Tips, tricks & shortcuts
| TYPE THIS | WHAT IT DOES | WHEN YOU'D REACH FOR IT |
|---|---|---|
/init | Reads the repo and writes a first CLAUDE.md for you. | Day one on any codebase |
/clear | Wipes the conversation and starts clean. | Moving to an unrelated task |
@ then a path | Points it at exact files instead of pasting them in. | Almost every prompt |
# then a rule | Adds that rule to memory so it sticks for next time. | The moment it repeats a mistake |
Shift+Tab | Cycles the modes: normal → auto-accept edits → plan-first. | Press until it says plan mode, before anything risky |
Esc | Interrupts it mid-run without losing the session. | It's heading the wrong way |
Esc Esc | Goes back and edits an earlier message. | You worded it badly |
claude --resume | Picks up a previous session where you left it. | Morning after |
| drag in an image | It reads screenshots — error dialogs, designs, a broken screen. | "Why does this look like that?" |
The one worth stealing today: when it gets something wrong twice, press # and write the rule down. That's the difference between a tool you keep correcting and one that learns your codebase.
✅ Keeping the code to one standard
Your rules in one file
How things are named, how errors are handled, never put passwords in code, always use safe SQL. Claude reads this file before every job.
The machine checks
A script runs the formatter and the code analyzers after every AI edit. Anything that fails goes straight back to Claude to fix.
A first pass before you
Every change is reviewed by AI against your checklist first. Then a person reviews the thinking and the business rules — not the spacing and brackets.
Tidy as you go
Any file the AI opens gets brought up to standard in the same change. The code slowly gets cleaner instead of slowly getting worse.
Worth saying out loud: AI doesn't make standards optional — it makes them cheap. The tidy habits you never had time for become the normal output.
🚫 Sensitive data: non-negotiable
✅ Fine to share with Claude
- Source code, stored procedures, schemas
- Stack traces & logs scrubbed of personal data
- Synthetic / dummy test data
- Architecture & design discussions
Before the first repo goes in, confirm your plan's data terms in writing — on business plans your content isn't used for training and your admin controls access; on individual plans it's a setting someone has to actually check.
❌ Never in a prompt
- Real personal data of users, customers or patients — names, IDs, account numbers, medical records
- Production database dumps or backups
- Credentials, connection strings, API keys
- Employee HR / payroll data
Habits: AI works on dev data only · scrub logs before prompting · secrets live in vaults, never in code Claude reads.
In regulated domains — healthcare, finance, government — this isn't a preference. It's the law. Case in point: a hospital HMIS, where every patient record is protected data.
⚠️ How teams get this wrong
Approving without reading
The danger isn't that the AI writes bad code. It's that nobody reads it before it ships. If you didn't understand the change, don't approve it.
Asking for too much at once
One giant change that nobody can realistically check. Ask for small pieces you can actually read, one at a time.
Juniors who stop learning
If you only ever ask, you never learn to judge the answer. Make Claude explain why — it happens to be the best teacher on the team.
Believing it when it sounds sure
Now and then it invents something that doesn't exist, and sounds completely confident doing it. Running the build and the tests is how you catch that.
One rule from day one: you own what you merge. "The AI wrote it" is not an excuse — just like "I copied it off the internet" never was.
👥 What changes for each role
Engineers
- From typing code → directing & reviewing it
- Tests & docs expected — they're cheap now
- Prompting becomes a core skill, the way Git did
Dev manager
- Owns CLAUDE.md quality & the standards it encodes
- Decides how much the AI is trusted with, module by module
- Keeps the team comparing notes on what's working
Juniors
- Best onboarding tutor ever — "explain this module"
- Rule: understand before you merge
- Meaningful PRs in week one, not month three
Nobody's job disappears. The scarce skills become judgment, domain knowledge, review — and your team holds years of domain knowledge no AI has.
🚀 What it takes to start on Monday
Individual or business
Business plans add central admin, seat management and the data terms compliance will ask for. Priced per seat, per month — get today's number off the pricing page before you commit anyone.
One command, one repo
Install once, then run claude inside a repo. Terminal, VS Code and JetBrains all work. Nothing to configure before your first real answer.
Let it read your code
Run /init — it reads the repo and writes your first CLAUDE.md. Then open a module nobody remembers and ask it to explain that module to you.
Session length, not headcount
Short sessions, /clear between unrelated tasks, subagents for the big searches. The habits two slides ago are the cost control.
The honest way to answer "what will this cost us?": one seat, one engineer, one month, on a real module — then you're arguing from your own numbers instead of someone else's slide.
The winning teams won't be the ones with AI —
everyone has AI.
They'll be the ones who rebuilt their habits around it: documented code, tested changes, enforced standards — and engineers who direct instead of type.
Your legacy codebase isn't a liability.
It's years of domain knowledge waiting for a team that can finally move fast on it.
This week: install it, open a module you didn't write, and ask it to explain that module to you.
QUESTIONS?
🔗 Resources & further reading
- Claude Code docs —
docs.claude.com/en/docs/claude-code· setup, CLAUDE.md, hooks, subagents, MCP - Anthropic: Claude Code best practices —
anthropic.com/engineering/claude-code-best-practices - Code modernization with Claude —
claude.com/solutions/code-modernization - Prompt engineering guide —
docs.claude.com/en/docs/build-with-claude/prompt-engineering/overview - Book: Working Effectively with Legacy Code — Michael Feathers (the characterization-test playbook)
- Yours to create: CLAUDE.md · PHI red-lines policy · a shared library of prompts that worked