I Use Claude as My Engineering Partner. Not an Assistant.
Most people use AI to autocomplete code. I use it to think through architecture, debug live systems, and ship things faster than I could alone. Here is what that actually looks like.
There’s a version of AI coding tools where you type a function name and it fills in the body. That’s useful, I guess. It’s also not what I do.
I’m a solutions and security engineer with over 10 years in IT — the last few deep in cloud security and infrastructure. The problems I’m working on aren’t “write me a React component.” They’re “why is my AI agent’s browser automation breaking under Docker’s network bridge but not in a VM” and “how do I fork an open source memory library to use Cloudflare’s free embedding API instead of OpenAI’s paid one without losing any features.”
Claude Code is the first AI tool that’s actually useful for that kind of work. Here’s why.
The difference between assistant and partner
An assistant waits for instructions. A partner pushes back.
When I’m deep in a problem - say, figuring out why Chrome’s DevTools Protocol silently ignores --remote-debugging-address=0.0.0.0 even in non-headless mode - what I don’t need is something that repeats my question back to me and offers three competing theories. I need something that will say: “I was wrong because X. The correct answer is Y. Here’s a test to verify it.”
That’s what I configured Claude to do. And it took some configuration to get there.
Out of the box, AI tools are trained to be agreeable. That’s a bug for engineering work. The first thing I did was set ground rules: no preamble, no validation, no hedging. If it can be verified in 5 minutes, verify it. Don’t write 20 lines of theory when a curl command gives the answer.
Once I got that right, something shifted. Instead of fighting the tool’s instinct to be helpful in a generic way, I started getting responses that were actually useful: direct, testable, committed to an answer.
What it looks like in practice
Last week I spent an evening building a working parking registration bot that could navigate a building management portal, fill a form, and submit it. What sounds simple had three layers of non-obvious problems.
The form was an old ASP.NET MVC app with field names like VisitorModel.ParkingPermitItem.VehicleMakeID. My browser automation tool uses a matchesSelector function that breaks when CSS attribute selectors contain dots. Claude identified the root cause in one pass: the matchesSelector function was doing attrs.name === sel and I was passing a CSS selector, not a name value. Two different things.
The fix wasn’t in the documentation. It was in reading the actual source code of the tool - which Claude did, identified the issue, and proposed a direct CDP eval approach as the bypass. No detours through “have you tried clearing the cache.”
The whole session - from “form isn’t submitting” to “new visitor was successfully added” confirmation screenshot sent to Telegram - was a few hours of real work, not a week.
How I set it up
I use Claude Code as a CLI tool running in my terminal. The configuration that matters most:
CLAUDE.md - this is where most people underinvest. CLAUDE.md is a project-level instruction file that Claude reads at the start of every session. Mine specifies: how I communicate (no preamble, direct answers), how I debug (test first, speculate later), what I care about (don’t retry the same failing approach, verify before declaring done), and what I never want (don’t add error handling for scenarios that can’t happen, don’t abstract things that only appear once).
That last one is important. A lot of AI-generated code is over-engineered. It adds fallbacks you don’t need, wraps things in classes that should be functions, and adds comments to code that’s already readable. The instructions in CLAUDE.md keep that instinct in check.
Memory files - Claude has a persistent memory system that lives in a local folder. I use it to store architecture decisions, gotchas, key file paths, and context that should be available in every session. When I discover something like “CF AI Gateway unified billing removes the free tier for routed providers,” that goes in memory. Next session, it’s already there.
Logging rules - after every meaningful session, Claude logs what we worked on to my Obsidian vault. This sounds minor but it’s changed how I retain knowledge across projects. I’m not chasing down which conversation had that one config snippet anymore.
The things it gets wrong
Claude Code is not perfect. A few honest notes:
It will sometimes start implementing before fully understanding the problem. I’ve learned to ask it to explain what it thinks is happening before it touches a file.
It can be overly cautious about destructive operations - which is actually correct behaviour most of the time, but occasionally needs overriding when I know what I’m doing.
It doesn’t know things that happened after its training cutoff, which matters for fast-moving tools. I’ve had to correct it on API changes in products that moved quickly.
And occasionally, after a long session, it loses track of early context and will suggest something it already tried. The memory system helps with this but doesn’t fully solve it.
What it enables
The short version: I ship things faster than I could alone, and they’re better because I have something pushing back on my decisions.
The project I described at the start of this blog - a personal AI agent running on a macOS VM, with semantic memory, multi-model routing, and browser automation, for $2/month - I built most of that in the gaps between family life and work. Early mornings, evenings after the kids are in bed. That pace was only possible because I wasn’t context-switching back to basics. Claude handled the implementation details while I kept the system design in my head.
That’s the right division of labour. I stay at the architecture level. The tool handles the code.
If you’re a developer thinking about how to get more out of these tools, the investment worth making is the CLAUDE.md file, not the prompting techniques. Tell it who you are, how you work, and what you don’t want. The rest follows.