Most engineers reach for AI as an autocomplete engine. I've built it into how I think about systems: a structured layer for decision quality, architecture clarity, and team-scaled output. The key difference is that I don't delegate thinking — I accelerate it.
I've formalized this into a reusable workflow that scales from individual engineers to entire teams:
Frame → Define the problem space and constraints before solving
Explore → Map 3–4 solution options with explicit tradeoffs
Structure → Design detailed architecture with clear boundaries
Implement → Execute in small, testable, reviewable increments
Harden → Make it production-ready and maintainable
This isn't just how I work — it's a methodology I've taught to engineering teams, complete with reusable prompt templates and context engineering patterns.
GitHub Copilot
Code-aware execution: refactoring, scaffolding, inline iteration, convention enforcement. I also authored team-wide Copilot instruction files that measurably improved output quality for every engineer who adopted them.
Role: execution engine
AI Chat (Claude, Copilot Chat, etc.)
Architecture decisions, tradeoff analysis, compliance alignment (IEC 62304, FDA), system-level design, documentation artifacts, and decomposing ambiguity into concrete structure before a line of code is written.
Role: strategy & systems thinking layer
Before generating anything, I define the constraint space: architecture boundaries, team conventions, compliance requirements, timeline, and mobile-specific considerations like Bluetooth or background processing. The better the frame, the better the output.
I push for multiple approaches with explicit tradeoffs rather than a single recommendation. This aligns with how I think about architecture: optimize for decision quality, not speed alone.
Folder structures, layer boundaries, interface contracts, ownership — these come before any code is written. I'm deliberate about coupling, cohesion, and testability upfront.
Once structure is clear, I move into milestones, test strategy, CI/CD expectations, and documentation approach. This is where planning connects to delivery — code, process, compliance, and release pipeline as a unified system.
Security, maintainability, testing coverage (unit / widget / integration), auditability, traceability. I treat AI outputs as inputs into an engineered system — not just code to ship.
I rarely jump straight to code. I model systems first, validate approach before implementation, and use AI to stress-test designs, fill in missing pieces, and surface coupling issues early.
Working in regulated environments (IEC 62304, FDA), I use AI to translate engineering work into compliant artifacts — not just to check code correctness. Process alignment is part of the loop.
AI acts as a documentation accelerator and structure enforcer. At Inspire, this became a per-feature README system aggregated into QMS-ready Software Design Documents — dramatically reducing the team's documentation overhead.
I use AI to generate examples, explanations, and reusable patterns — scaling knowledge across the team, not just my own output. The Copilot instruction files I authored at Inspire are a direct example of this.
AI accelerates my work — it doesn't replace my judgment. I validate outputs against architecture, hold final authority on decisions, and keep strong ownership over what gets built and why. The goal is decision quality, not just throughput. I preload AI with real constraints, shape the output space deliberately, and treat what comes back as a starting point for review — not a finished answer.