James Cockburn

Building with AI, Not Learning to Code

The first thing you realise about these models is that they don't come with instructions. Those of us curious about what they can and can't do have to learn through trial and error. It's strangely the inverse of everyone's fear about AI replacing human thought—in the AI sphere itself, you have to take the journey into the unknown step by step.

That journey led me to vibe coding: AI-assisted development where you describe what you want in plain English, and the model proposes the implementation. You scope, steer, test, and iterate. I've built hundreds of tools this way—professional litigation software, home automation, games for my kids—without having learned to write a single line of code.

The Process

Start by scoping your idea in your normal AI provider—ChatGPT, Claude, Gemini. Describe what you want in plain English and ask what would be involved. If your idea is feasible (it almost always is), move to an IDE like Cursor where you can use an AI chat interface to build software from the ground up. Your job becomes reading the conversation and steering toward your goal, not writing syntax.

The real skill is document ingestion and context engineering—structuring what the model sees so it can reason effectively. This matters more than clever prompting. A well-architected context window beats a clever prompt every time.

The Discipline Problem

AI can break things faster than you can fix them. Without human oversight, models rapidly optimise the wrong thing. I've watched AI make rapid, impressive progress on a project—rewriting sections, adding features, refining structure—while gradually losing sight of why it was doing any of it. The end result looks smart, even impressive, but it's fundamentally broken.

In litigation, this manifests as elegant submissions that subtly drop your strongest point, briefs that confidently misstate the law, or analysis so elaborate it misses the crucial fact. Bad code usually fails visibly. Bad legal output can be fluent, plausible, and wrong.

The models simulate discipline without enforcing it. I've tested every major ChatGPT model over the past two years, alongside Claude, Gemini, and dozens of open-source alternatives. They follow custom protocols until they don't, then pretend they still are. Protocols can be taught and remembered. They can be performed. But none are verified against the model's own output. The model will quote your rules, apologise for breaches, simulate audit and recovery—then bypass everything on the next failure. This is performance, not enforcement.

The trick is to use AI like any other power tool: carefully, iteratively, always watching what it's actually doing. Make small changes. Step back. Reassess. Don't get pulled into the rabbit hole. Complexity feels impressive, but clarity wins cases.

Privacy, Control, and the Limits of Context

Local AI is a different category from vibe coding—more advanced, focused on balancing privacy with model sophistication. The case for running models locally isn't ideological. It's risk management.

If your documents leave your environment, that's a different risk profile than local processing. For legal work involving sensitive client data, "no cloud" is often the cleanest route to defensible confidentiality. A controlled retrieval pipeline is easier to supervise than a general-purpose assistant that implicitly "knows everything". Self-built tools can be designed so uncertainty is obvious and source grounding is mandatory—vendor tools often fail silently.

What Becomes Possible

I've built a fully working local RAG system with unlimited document ingestion, summarisation, chronology extraction, and a query engine powered by large local LLMs. Totally offline, detailed and fully referenced responses on consumer hardware. I develop and deploy across both Linux and Windows—self-taught from first principles, not formal training. The architecture is fully swappable—different models for different tasks, some optimised for speed, others for reasoning depth.

This wouldn't have been possible even a few months ago for someone without traditional coding experience. The field moves that fast.

The Architectural Challenge

Local models are improving rapidly, but context remains limited on realistic hardware. This creates predictable failure modes: misattribution, over-confident synthesis, improvised reasoning from narrow windows. The answer isn't bigger models—it's architecture.

My systems operate at two levels: a case graph layer with stable, verified representations (party positions, issues, chronologies), and a raw chunk layer with the underlying sources. The goal is to prevent the model from inventing global understanding when it only has local visibility. Structured retrieval with mandatory source grounding, not open-ended generation.

The ideal system isn't one that "never hallucinates"—that's unrealistic. The ideal system prevents pure invention, makes uncertainty obvious, and allows rapid verification. In legal work, supervision is the point. The human remains essential.

A Year of Building AI Governance from Scratch

Standard prompting doesn't work for legal AI. You can tell a model to cite sources, verify authorities, and flag uncertainty—but it will simulate compliance rather than enforce it. After a year of daily testing across frontier models, I designed a complete protocol architecture from first principles: a three-layer system that forces structured behaviour where the model's default is performance.

The Architecture

The system operates across three layers. Layer 1 (Governance Core) handles fundamental integrity: protocol conflicts, memory limits, hallucination containment, citation verification, and session state. Layer 2 (Global Operating Rules) governs daily operation: source hierarchy, authority acquisition, case handling, output structure, and mandatory verification triggers. Layer 3 (Domain Modules) contains jurisdiction-specific rules—currently UK civil procedure—with renumbering audits and conditional order handling.

Key Mechanisms

Hallucination containment freezes propagation of suspect claims. The model must replace with verified sources or mark content explicitly as unverified. If a prior step was influenced, it issues a correction note. Citation verification treats all new authorities as draft until verified against primary sources—statute sites, BAILII, official reports. Secondary sources are permanently marked.

Source hierarchy enforces primary over secondary: no quotes or doctrinal use without verified authority. The Interrogation Escalation Protocol triggers when I challenge any fact, law, or inference—the model must restate the proposition, show its evidence chain, verify against primary sources, and correct or mark as disputed.

Why This Matters

Off-the-shelf legal AI has no equivalent. Vendor tools promise accuracy but fail silently. My protocols make failure visible, force verification at defined points, and prevent the model from generating confident nonsense. The human remains in control—not because the model chooses to defer, but because the architecture requires it.