How I Build

My approach brings together modern engineering practices and strong architectural foundations. The practices help teams build, deliver and improve software. The foundations give clarity, context and boundaries. Together, they make software easier for people to understand, easier for agents to work within, and easier to change over time.

Modern Engineering Practices

These are some of the practices I use to help people and agents build, ship and learn.

  • AI-Assisted Engineering

    Working with coding agents such as Claude Code, GitHub Copilot and Cursor, with clear context, guardrails and review.

    Why It lets agents take on more of the work while people stay in charge of intent, design and quality.

  • Cloud-Native Engineering

    Designing systems for the cloud, built from managed and serverless services such as Azure Functions, Service Bus and App Services.

    Why Standard, well-documented building blocks are easier for people to reason about and for agents to use correctly.

  • Developer Experience

    The tooling, conventions and feedback loops that shape a team's everyday work.

    Why When the right path is the easy path, people and agents both follow it.

  • Quality Engineering

    Unit and integration tests, automated checks and code review.

    Why Tests give agents a quick feedback loop to check their own work, and give people confidence in what they and their agents have built.

  • Continuous Delivery

    CI/CD pipelines and small, regular releases.

    Why Small changes are easier for people to review and for agents to get right, so the team can move quickly and safely.

  • Observability

    Logging, metrics and tracing that show how software behaves in production.

    Why It feeds back how software really behaves, so people and agents can find and fix problems rather than guess.

Strong Architectural Foundations

These are some of the principles and patterns I use to keep software understandable and adaptable, for people and agents.

  • Software Design Principles

    Clean Code, SOLID, DRY, KISS and YAGNI, and separation of concerns. They're guidelines rather than rules, so I apply them where they help, not everywhere.

    Why Clear, consistent code is easier for people to read and gives agents good patterns to follow.

  • Domain-Driven Design

    Shaping code around the business domain and its language, with clear boundaries between areas.

    Why A shared language means people and agents describe and build the same thing.

  • API-First Design

    Agreeing API contracts, often with OpenAPI, before writing the code behind them.

    Why A clear contract gives people and agents an exact target to build and test against.

  • Vertical Slice Architecture

    Organising code by feature rather than by technical layer.

    Why Each change lives in one place, so people can review it easily and agents need less context to get it right.

  • Modular Monoliths

    One deployable application split into well-defined modules.

    Why It can be a good way to get clear boundaries without the overhead of microservices, so people and agents can work on one module without breaking another.

What They Have In Common

The same few ideas run through all of these practices and foundations. Together, they keep software clear, safe to change and easy to check.

  • Clarity Gives Context

    Clear code, a shared language, clear contracts and clear boundaries help people understand the software, and mean agents need less context to get things right.

  • People Stay In Charge

    Agents take on more of the work, while people keep control of intent, design, review and quality.

  • Small, Safe Changes

    Changes stay small and contained, so the system can keep improving without breaking what's already there.

  • Faster Feedback Loops

    Tests, contracts, pipelines and production signals tell people and agents quickly whether a change works, so they can correct course early rather than guess.