My Approach
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.
Underpinning both is the human side of software: helping the people behind it grow, share what they know and work well together.
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 for the cloud with 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:
- 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.
The Human Side Of Software
I believe that technology succeeds when people succeed. These are some of the ways I help teams grow and work well together.
-
Mentoring
Helping developers grow their skills and confidence.
Why Confident engineers make better decisions, ask better questions and go on to support others.
-
Technical Leadership
Leading teams and technical direction while staying close to the code.
Why Staying hands-on keeps decisions grounded in how the software is really built.
-
Knowledge Sharing
Sharing ideas across teams and organisations, through groups, presentations and writing.
Why Good practice spreads further when it's shared, and teams avoid solving the same problem twice.
-
Introducing New Practices
Bringing in new standards, tools and ways of working, and helping teams adopt them.
Why New practices only help when teams understand them and use them every day.
-
Cross-Team Collaboration
Working closely with other teams, third parties and external partners.
Why Many problems sit at the boundaries between teams, so working across them avoids surprises late on.
-
Stakeholder Engagement
Working with clients and stakeholders to keep things clear and practical.
Why Clear goals and a shared understanding mean teams build the right thing first time.
Behind all of these are the everyday soft skills that make any engineer easier to work with: thinking critically and staying curious, communicating clearly and kindly, being humble enough to ask for help and change your mind, making decisions and saying no when it matters, and looking after your own focus and energy. Addy Osmani's Software Engineering: The Soft Parts covers them well.