Articles / AI Workflow
I build with AI every single day.
This is how I actually use AI tools — not in theory, but in the real daily practice of writing software.
The Stack
Five tools.
One clear purpose each.
I don’t use every AI tool for everything. Each one has a job, and I’m deliberate about which I reach for.
Core Tooling
IDE CLI
Command-line integration for seamless IDE workflows and local automation.
- →Terminal-first development
- →Direct IDE control from scripts
- →Automated environment setup
Click to expand
Reasoning & Context
Claude Code
My primary thinking partner. Architecture decisions, complex debugging, and understanding large codebases at once.
- →Writing implementation plans before touching code
- →Multi-file refactors with full codebase context
- →Security reviews and root cause analysis
- →Reading and editing files directly via MCP
- →Creating GitHub PRs automatically
Click to expand
Speed & Generation
Codex
When the spec is clear and I just need it written. Fast, pattern-focused, great for filling in implementations.
- →Generating implementations from clear interfaces
- →Producing multiple variants to compare
- →Filling in repetitive, well-known patterns
- →Quick one-off transformations and migrations
Click to expand
Private & Overnight
OpenCode
Locally hosted. No API limits. The engine I use for private codebases and autonomous overnight tasks.
- →Client code that can't leave the machine
- →Overnight jobs without rate limits or costs
- →Full control over the agent loop behavior
- →Experiments before they're ready to share
Click to expand
Autonomous Agents
Anti Gravity
Advanced agentic coding framework for complex, multi-step engineering tasks.
- →Multi-agent collaboration
- →Complex problem solving
- →End-to-end task execution
- →Extensive tool usage and integrations
Click to expand
What I Use
The extended
daily toolkit.
Beyond AI, these are the tools and platforms that keep my workflows running smoothly every single day.
OmniRoute
Intelligent routing and API gateway.
n8n
Workflow automation and node-based integration.
cowork
Collaborative workspaces and sharing.
Obsidian
Personal knowledge base and markdown notes.
Pi Agents
Personal intelligence and automated tasks.
GitHub Actions
CI/CD and repository automation.
The Loop
Think. Build. Test. Ship.
Engineering isn't a straight line. Implementation frequently reveals new information that changes the original plan. You don't execute one-way; you move back and forth through these phases in a continuous feedback loop until the code is right.
Phase 01 · Think
Constraints first. Code later.
Before planning, I spend time validating assumptions and discovering hidden requirements. Once the problem is defined, the AI drafts an implementation plan. We iterate on architecture, tradeoffs, and edge cases until the approach is solid. Plans are living documents.
- ✓Define success criteria and constraints
- ✓AI drafts a structured implementation plan
- ✓I resolve ambiguity and make product decisions
- ✓Plan evolves as we discover new information
Skills & Plugins
Packaged knowledge.
Loaded on demand.
Skills encode my team’s conventions once. The agent applies them consistently — every time, without being reminded.
Architecture Review
Validates distributed system design, tradeoffs, and scaling bottlenecks.
TDD
Enforces test-first. Validation happens continuously alongside implementation.
No-Mistakes
Full validation pipeline (lint, types, tests) before any code is pushed.
Code Review
Pre-PR review from a fresh, independent AI perspective.
Security Audit
Checks every diff for common vulnerabilities and trust-boundary flaws.
Observability
Ensures proper logging, metrics, and tracing are included in new features.
Firebase
Connects to real project, validates security rules live.
BigQuery
SQL best practices, partition rules, cost guardrails.
Diagnose Bugs
Root cause analysis. Fix the source, not the symptom.
A Real Day
How the hours
actually run.
AI didn’t change what I build. It changed how I spend the hours building it.
9:00 AM
Review overnight PRs & Telemetry
The AI ran tasks while I slept. I check production logs, read the PR descriptions, and review CI results. My job is direction—is this the right solution? Usually it is. 30 minutes.
9:30 AM
Discover & Plan
I define the problem and constraints. The AI drafts an architecture plan. We iterate to resolve ambiguity and edge cases. The plan is a living document, not a rigid spec.
10:30 AM
Implementation & Continuous Validation
The agent executes the plan file by file. Tests and linters run in the background. I review tradeoffs and steer the architecture. When we hit an unexpected constraint, we revise the plan.
2:00 PM
Debugging a Failed Assumption
Integration tests reveal a race condition we didn't account for. We don't just patch it—we loop back, update the mental model and the plan, and refactor the core logic. Fix the root cause.
4:00 PM
Ship & Monitor
Agent creates the PR. CI passes. I approve and merge. Once deployed, I check the monitoring dashboards to ensure the new metrics look healthy and no new errors are spiking.
10:30 PM
Queue overnight tasks
Well-scoped, low-risk work (like migrations or test backfilling). Clear specs, AI runs them autonomously. The results are waiting in the morning.