Using AI to build faster
without lowering the bar.
Tools change. Judgment doesn’t.
$ explore –architecture clean-mvvm
✓ Analyzing patterns across 847 files…
✓ Identified 3 refactor opportunities
✓ Generated migration plan
$ generate –tests –coverage 90
✓ Writing unit tests for PaymentViewModel…
✓ 47 tests generated, 0 failing
$ review –pr –senior-engineer█
I use AI-assisted development tools to speed up the parts of software engineering where they are genuinely useful: exploring implementation options, generating boilerplate, writing and refining tests, reviewing unfamiliar APIs, analyzing build and runtime logs, improving documentation, and prototyping product ideas quickly.
The key is judgment. AI can accelerate the work, but it does not replace architecture, product thinking, code review, debugging discipline, or responsibility for what ships.
faster prototyping
reduced accountability
senior review still required
Architecture Exploration
Rapidly evaluating trade-offs between patterns before committing to an approach. Faster than reading three blog posts and a Stack Overflow thread.
Boilerplate & Scaffolding
Generating repository classes, DI modules, data layer plumbing, and test skeletons — the necessary but non-interesting parts of a codebase.
Test Generation
Writing and refining unit tests, edge case coverage, and parameterized test suites. High-coverage testing without the time sink.
API & SDK Review
Quickly getting up to speed on unfamiliar SDKs, libraries, or platform APIs without wading through pages of documentation cold.
Log & Crash Analysis
Parsing build logs, ANR traces, and crash reports. Finding the signal in the noise faster when something is on fire in production.
Rapid Prototyping
Going from product idea to working prototype fast enough to validate the concept before investing in production-quality implementation.
These are exciting times.
Still learning.
The surface area of what’s possible is expanding faster than any one engineer can fully map. My role is turning that chaos into working software.
AI Code Review
Using LLMs as a first-pass reviewer to catch obvious issues before human review. Calibrating false positive rates and building team trust in the signal.
Context-Aware Tooling
Building dev tooling that understands the specific codebase — custom prompts, repo-aware agents, and Claude Code hooks for project-specific workflows.
Private Local LLMs
Running models locally for code tasks that shouldn’t leave the machine. Ollama, quantized models, and practical trade-offs between capability and privacy.
Agent Teams
Coordinating multiple specialized AI agents on engineering tasks — one explores, one implements, one reviews. Early days but genuinely interesting results.