Tooling & Integration
How the pieces fit together: editors, build systems, CI, protocols and the day-to-day mechanics of shipping software.
Local and Hosted Models: Deciding on Data Flow, Not Benchmarks
What actually leaves your machine under each arrangement, why the consumer-versus-business tier distinction matters more than local versus hosted, and how to enforce a hard boundary.
Constrained Decoding: Making Invalid Output Unreachable
Why schema-constrained sampling is a different guarantee from retry-and-parse, how field ordering in a schema steers generation, grammars for non-JSON output, and what constraint cannot check.
Event-Driven Agent Jobs: Fire on Change, Produce Information
Why scheduled agent jobs waste tokens and arrive detached from context, which events are worth wiring, the permissions design that keeps them safe, and how to stop them becoming noise.
Context Caching and Reuse: What Survives Between Sessions
Three unrelated mechanisms people call caching, how to order prompts so prefix caching works, and the distinction between caching understanding and caching state.
Contract Mocking: Structure From the Spec, Values From the Model
Why hand-written mocks decay into actively harmful tests, generating the skeleton from OpenAPI, using a model only for interesting fixture values, and checking the spec still matches reality.
Instrumenting Agent Sessions: Metrics That Aren't Vanity
Why lines generated and suggestions accepted mislead, five metrics worth tracking instead, and a three-checkbox PR template that makes them queryable.
Giving Claude a Second Opinion: Connecting Gemini Through a Local MCP Server
A working walkthrough for wiring another model into Claude Code as a tool: the server code, the registration command, the flag ordering that breaks it, and why the context parameter is the part people get wrong.
Benchmarking Autocomplete: Measure Latency, Not Completion Quality
Why inline completion is latency-bound rather than capability-bound, what the p95 path actually contains, a harness using your own cursor positions, and why retention beats acceptance rate.
How Deep Is Your LSP Integration? Three Probes That Tell You
Four levels of language-server integration, three five-minute probes that reveal which one you have, and how to reach query access yourself when the tool does not provide it.
Build System Integration: Your Toolchain Is the Agent's Feedback Loop
Why build quality bounds agent output, four properties that matter, the failure modes specific to agents, and why you should verify your check command actually fails on failure.
Running Coding Agents in CI: Guardrails for Unattended Work
What changes when no human is watching, which tasks are safe to automate, and the five controls that turn an unattended agent job into a bad pull request rather than a bad deployment.
Types as the Contract: A Decision Procedure Downstream of a Generator
Why strict typing pays more now that annotations are written for free, exhaustiveness checking as the guard against missed variants, signatures as specification, and where types stop helping.
Sandboxing Agent Environments for Reproducibility, Not Just Safety
The operational case for containerising agent sessions: environment drift, parallel work and cleanup. A working setup, the mounts to refuse, and how to make the sandbox the easy path.
Reviewing Agent-Authored Code: The Author Cannot Answer Questions
Why agent code defeats the heuristics reviewers rely on, five questions that reliably find real defects, and how to make the pull request reviewable in the first place.
Terminal Agents and IDE Agents: Ambient Versus Explicit Context
Why two agents running the same model behave differently, which tasks suit each surface, and the handoff problem when you use both.
Building a Local MCP Server: Exposing What the Filesystem Cannot Answer
A working TypeScript MCP server over stdio, why the tool description decides whether it is ever called, returning errors the model can read, and the read-only role to create before it runs.
IDE Extensions for an Internal Agent: Keep the Plugins Thin
Why implementing an agent twice in TypeScript and Kotlin fails, what belongs in a local daemon, the staleness guard both plugins need, and IntelliJ's threading rules.
Static Analysis in the Loop: Linters as Feedback, Not Just Gates
Machine-readable linter output, why agents suppress rather than fix, a CI check that blocks it, and which rules are worth enabling once an agent actions them for free.
Normalising Agent Commits: The Only Surviving Record of Intent
Why commit quality matters more when the author cannot be asked, a format worth enforcing with a hook, declaring agent involvement in trailers, and keeping CI checks to the two that should fail.
LSP and Agents: Two Different Models of Understanding Code
A language server holds a resolved symbol graph; an agent holds text in a window. Why one says 'not found' and the other invents, and how to combine them.
Orchestrating Parallel Agent Sessions Without Corrupting Your Repo
Why two agents in one checkout reliably interfere, three ways to isolate them, how to split work so it stays independent, and why parallelism often just lengthens the review queue.
Other pillars
- Context Architecture — How a codebase explains itself — context files, documentation and conventions structured so the right material is found at the right time, by a person or a tool.
- Security Engineering — Threat models, trust boundaries and controls for systems that hold credentials, execute code and call tools on your behalf.
- Workflow Architecture — Designing the loops work happens inside — instruction design, migrations, test-driven cycles and the gates that keep a codebase coherent over time.
- Codex vs Claude — Practical comparisons across execution, security, cost, speed, orchestration, planning, integrations and verification — each examined as a decision a working developer can test.
- Higgsfield AI — A practical field guide to Higgsfield's generation, camera, consistency, advertising, audio and editing workflows — including the limits hidden by feature names and the checks that prevent wasted renders.
- Flow vs Higgsfield — A beginner-focused comparison of Google Flow and Higgsfield across models, mobile use, story building, camera control, editing, integrations and the real cost of accepted video.
- Humanoid Robots — Practical buying guides for commercially offered humanoid robots, separating published specifications from configuration, integration, safety, privacy and procurement obligations.
- ChatGPT vs Grok vs Claude Code — A practical comparison of three increasingly broad AI products across identity, interfaces, files, autonomy, search, coding, media, memory, integration, safety and the work each is best equipped to own.
- Tesla Roadster — Evidence-aware engineering guides to twenty-five announced, proposed and prototype Roadster features — separating Tesla's published targets from executive claims, visible concepts, engineering inference and unsupported expectations.