Skip to main content
<JayDev />

/ ai-workflow

How I work with AI in 2026

AI is the best amplifier for a good engineer — and the worst excuse for a mediocre one. My approach starts from the Human-In-The-Loop standard: I am the architect, I run the cost math, I pick protocols, models and technologies; AI executes within the guardrails I define.

Human-In-The-Loop · Architect-led · Cost-aware

Philosophy: why Human-In-The-Loop

Generative AI changed how code gets written, but not who is responsible for the software that reaches production. On every project I ship, my role is that of architect and critical reviewer: I decide what to build, how to split it, which patterns apply and which risks to take. AI is a lever, not autopilot.

Working well with AI means making explicit trade-offs: do I use a large expensive model for this task or a small fast one? Do I parallelize agents or serialize for coherence? What context window do I actually need? These questions are not delegated; they are answered with technical judgment and documented.

My role as a software architect

  • Domain modeling

    Before any code, I define entities, relationships and business invariants. Without this, no AI can generate something that won't have to be thrown away.

  • Cost calculation

    I estimate cost per request, per feature and infrastructure cost. The question "how much does this cost monthly at 10× users?" gets answered before coding.

  • Protocols & contracts

    I define event schemas, API contracts and idempotency policies. Services talk through contracts, not accidents.

  • Tech selection

    I pick a stack based on fit, ecosystem and maintenance cost — not hype. Decisions live in the design doc.

Tools I use day-to-day

I select the right agent and model for each task. No vendor owns my entire flow: deliberate rotation by cost, quality and latency.

Editor

Windsurf

editor

Primary editor

Agentic IDE I live in day to day. I use it for its deep integration with agentic flows, MCP and custom skills.

AI agents

Claude Code

agent

Multitasking & system quality

My go-to agent for long tasks, structural refactors and reasoning about whole architectures without losing context.

Codex

agent

Bug fixing & refactor

For localized problems and precise refactorings. I pick it when I need fast iteration on a single file or module.

Gemini

agent

Ideation & image generation

For early brainstorming, image generation and visual exploration when a project needs thematic assets.

Methodologies & standards

What makes an AI workflow reliable is not the AI, it's the guardrails. These are mine.

Human-In-The-Loop

method

Cross-cutting standard

AI accelerates; I decide. Every architectural decision, cost, model and trade-off goes through my review before landing in production.

MCP (Model Context Protocol)

method

Tool integration

I connect models with databases, deploys and external services via MCP rather than ad-hoc hacks: clear contracts, auditable, reusable.

SDD (Spec-Driven Development)

method

Planning discipline

Every relevant feature starts with proposal → spec → design → tasks. This lets me delegate implementation to agents with guardrails.

TDD

method

Tests first where it matters

Tests before code in critical business logic (payments, inventory, auth). Speeds up iteration with AI instead of slowing it down.

Human code review

method

Non-negotiable checkpoint

No AI-generated PR merges without human review. AI is not responsible; I am.

Events & concurrency

method

Design default

I design event-driven, async and parallel-by-default systems. Reduces latency and decouples subsystems that grow at different rates.

Skills

method

Reusable knowledge

I encapsulate recurring patterns (postgres, accessibility, frontend design) as skills my agents invoke on demand.

Per-task selection

method

Right model for each case

Each task picks the model that solves it best by quality/cost/latency. No single model owns everything.

A real flow, from start to finish

  1. 01 · DISCOVERY

    Understand the problem (no AI)

    I talk to the client or the domain, write the problem in my own words, identify real constraints (budget, existing stack, deadlines).

  2. 02 · PROPOSAL & SPEC

    Define what gets built (AI as sparring partner)

    I use SDD: proposal, specs with scenarios, and a short design doc with the technical decisions and trade-offs. AI challenges my decisions; I decide.

  3. 03 · COST & MODEL SELECTION

    Run the cost math, pick models

    I define which tasks justify a big model and which a cheap one. I document estimates per month and per feature.

  4. 04 · IMPLEMENTATION

    Implementation with agents under guardrails

    Backlog tasks run on agents (Claude Code for multitasking, Codex for targeted refactor). Every change goes through a branch with tests.

  5. 05 · HUMAN REVIEW

    Human code review before merge

    I review every PR as if a brilliant junior wrote it: read everything, question decisions, verify tests, measure performance impact.

  6. 06 · OBSERVABILITY

    Measure in production

    Structured logs, metrics, alerts and tracking of real AI cost per feature. What you don't measure, you don't improve.

Looking for someone who understands both AI and architecture?

If you're hiring for roles where AI must integrate into a serious system — not as a gadget — let's talk.

Contact me View projects →