Pavlo Puzikov
Menu

Dubai · 2026

Back to portfolio

Practice · Agentic workflow

Building with agents.

I ship as a single operator with agentic AI doing the heavy lifting under a tight operating contract. Four parts: a loop every task runs, a library of reusable engineering skills, the principles that keep an agent honest, and the tool stack it reaches for.

The loop

Every task runs the same loop.

  1. 01

    Specify

    Pin the intent before any code.

  2. 02

    Plan

    Order the work; surface the trade-offs.

  3. 03

    Build

    Small, test-first increments.

  4. 04

    Verify

    Review, debug, harden, measure.

  5. 05

    Ship

    Gate, launch, document.

  6. 06

    Learn

    Retro feeds the next loop.

the retro feeds the next loop. It is a cycle, not a line.

The skills

An operating system of skills.

Twenty-one reusable skills, one per recurring engineering job, grouped by loop phase.

01Specify

Turn a fuzzy ask into a contract before a line of code.

  • Spec-driven development

    A spec before the code.

    spec-driven-development

  • Planning & task breakdown

    Specs become ordered tasks.

    planning-and-task-breakdown

  • Idea refine

    Diverge, then converge.

    idea-refine

  • Context engineering

    Tune the agent's working context.

    context-engineering

  • API & interface design

    Stable boundaries, public surfaces.

    api-and-interface-design

02Build

Implement in small, reversible, test-backed steps.

  • Test-driven development

    Tests drive the code.

    test-driven-development

  • Incremental implementation

    Ship changes one step at a time.

    incremental-implementation

  • Source-driven development

    Ground decisions in official docs.

    source-driven-development

  • Frontend UI engineering

    Production-quality interfaces.

    frontend-ui-engineering

  • Code simplification

    Clarity without changing behavior.

    code-simplification

03Verify

Prove it works and that it cannot be made to break.

  • Code review & quality

    Multi-axis review before merge.

    code-review-and-quality

  • Debugging & recovery

    Systematic root-cause debugging.

    debugging-and-error-recovery

  • Security & hardening

    Harden against the obvious classes.

    security-and-hardening

  • Performance optimisation

    Find and fix the real regression.

    performance-optimization

  • Browser testing

    Verify in a real browser.

    browser-testing-with-devtools

04Ship

Land it cleanly and leave a trail the next loop can read.

  • Git workflow & versioning

    Disciplined branches + commits.

    git-workflow-and-versioning

  • CI/CD & automation

    Automate build and deploy.

    ci-cd-and-automation

  • Shipping & launch

    Pre-launch checks, then launch.

    shipping-and-launch

  • Deprecation & migration

    Remove and migrate safely.

    deprecation-and-migration

  • Documentation & ADRs

    Record the decisions, not just the code.

    documentation-and-adrs

Using agent skills using-agent-skills

The meta-skill: Discover and invoke the right skill for the moment. It is how the other twenty get picked.

The principles

The rules that keep an agent honest.

Standing rules, distilled from a working CLAUDE.md, that an agent and I both hold every session.

01Decision markers

// WHY:, // DECISION:, // TRADEOFF: above any non-obvious block.

Future readers grep the code, not your memory.

02Two strikes

After two failed attempts on one approach, stop and present alternatives.

Stacking fixes on a wrong idea costs more than a reset.

03Approach-first

For non-trivial pivots, propose two or three options with trade-offs before coding.

Don't commit a stack from a single guess.

04Plan files

Long sessions get a plan: goal, approaches tried with outcome, next steps, and a do-not-retry list.

Stops re-trying reverted experiments across context resets.

05Commit the working state

Snapshot green before anything experimental; one experiment at a time.

A clean revert beats untangling cascaded regressions.

06Verification gates

Typecheck, build, and look at it before shipping. Revert broken changes immediately.

Report outcomes faithfully; if it failed, say so with the output.

07Scope discipline

Stick to the stated request. Adjacent improvements are suggestions, not silent drift.

The ask is the contract; surprises erode trust.

08Output discipline

No full-file dumps. Edit in place and reference path:line.

Context is finite; spend it on the work, not on echoes.

The stack

The tools it can reach.

MCP servers wired in by role, so the agent can read code, search, drive a browser, and touch infra without leaving the loop.

Code intelligence

codesightgitnexus

Reasoning & coordination

sequential-thinkingclaude-peers

Web & research

firecrawltavily

Browser & 3D

playwrightcesium

This is how the site, and most of the work in it, gets built.