Workflow Architecture
Designing the loops work happens inside — instruction design, migrations, test-driven cycles and the gates that keep a codebase coherent over time.
Test-Driven Loops: Giving an Agent a Definition of Done
Why TDD fits agent workflows, who should own each step of the cycle, the instruction that makes it runnable, and why test speed is the binding constraint.
Generating Schema Migrations: The One Loop That Ends With a Human
Why migrations are the asymmetric case, the inputs an agent must have rather than infer, expand–contract as a stated rule, locking requirements, and testing against restored production volume.
CI Gating for Agent-Generated Pull Requests
Why agents pass the traditional gate more easily than humans, seven checks worth adding, diff coverage over total coverage, and why model-graded review should never be the gate.
REST to GraphQL: Design the Schema Yourself, Delegate the Resolvers
Why an agent-generated GraphQL schema ends up shaped like your endpoint list, the N+1 pattern it will write by default, and the field-level auth check the migration tends to lose.
Structural Refactoring: Have the Agent Write the Transformation, Not the Edits
Why a tree-sitter query plus a deterministic apply script beats an agent editing four hundred files, the four-stage workflow, and the syntactic limits to verify around.
Fine-Tuning for an Internal DSL: The Case Is Narrower Than It Looks
Why in-context examples usually beat a fine-tune for proprietary syntax, how to categorise the failures you actually have, and the baseline comparison teams skip.
Preventing Architectural Drift in a Codebase Agents Contribute To
Why higher change volume accelerates drift, the five forms it takes, making canonical utilities findable, and a quarterly structural snapshot that catches what rules miss.
Designing Migration Instructions: Modernising Without Changing Behaviour
Why framework migrations go wrong with agents, splitting mechanical from semantic work, the instructions that preserve behaviour, and batching so review stays possible.
Measuring AI Impact: Ask the Questions That Have Answers
Why 'are agents worth it' is not empirically tractable, the narrow comparisons that are, reusing delivery metrics that predate the tooling, and the three ways this measurement goes wrong.
Finding Technical Debt: Parse for Candidates, Then Judge Them
Combining AST metrics with git churn to rank debt, using a model to rule out essential complexity, correlating with modules that actually produce bugs, and writing a register people act on.
Java to Kotlin: The Converter Does Syntax, the Agent Does Semantics
Why mechanical conversion produces Kotlin that reads like Java, recovering nullability intent from database constraints and call sites, the staged sequence, and where JVM interop bites.
Layering Agent Instructions: Personal, Project and Path-Scoped Rules
Three instruction channels teams routinely confuse, a test for which layer an instruction belongs in, and why explicit prohibitions outperform stated preferences.
A DSL Fine-Tuning Pipeline: Validator First, Training Script Second
The QLoRA pipeline for a proprietary DSL once you have established the case: compiler-backed dataset validation, AST mutation for expansion, error-correction pairs, and evaluating on parse rate rather than loss.
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.
- Tooling & Integration — How the pieces fit together: editors, build systems, CI, protocols and the day-to-day mechanics of shipping software.
- 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.