Intent

Intent

4 min read Original article ↗

For decades, the job was writing code. When AI handles that, the job becomes something bigger: setting direction, deciding outcomes… operating at the level of intent.

Add Interactive Maplogistics-ai/app

Spec drafted for the live delivery map. Inspecting the Figma for details. Awaiting your review/approval before delegating implementation.

Spec

The Live Map must read as a polished, production-grade dispatcher console — not a map with widgets bolted on. Every surface is measured against the Figma design.

Fidelity Checklist

  • Color palette (brand, status: en route / arriving / delivered / delayed, neutrals, map-tinted surfaces) encoded as tokens.
  • Type scale (font family, sizes, weights, line-heights, letter-spacing) matches Figma; correct web fonts loaded with fallbacks.
  • Light theme complete; dark/map-dark surface tokens defined
  • Icon set matches Figma (size, stroke, optical alignment)
  • Zoom control disabled state at min/max zoom rendered per design.
  • Destination pin variants (active, arriving, delivered, delayed)
  • Dropped pin has its own styled variant + drag affordance.
  • Status badges use correct status color tokens
  • Loading skeletons/empty states for rail and card match design.
  • Contrast (WCAG AA) verified for text/markers over the map at multiple zoom levels.

Add API Endpointlogistics-ai/app

Done: all five Mapbox endpoints implemented and verified (76 tests, build and lint clean). Changes are uncommitted on api-add — tell me if you want them committed.

Coordinator

Approved — start delegating the first wave.

Delegating

Wave 1 delegated.

Started - Scaffold Next.js App Router TypeScript project (implementor agent running).

Held on dependencies — the other four, as designed:

  • Mapbox client core → waits on scaffold
  • Geocoding, Directions, Matrix/Optimization → wait on client core

Estimated ~90 min of serial work on the critical path.

Next: when the scaffold agent completes I'll delegate a verifier, then release the client core task, and after that run geocoding + directions + matrix/optimization as one parallel wave.

Ending my turn to wait for the scaffold agent.

Verifying scaffold>

Verifying

Scaffold task completed: Next.js 16 App Router + TypeScript, strict tsconfig with @/* alias, Vitest (node env), ESLint flat config, .env.example with MAPBOX_ACCESS_TOKEN, and smoke test. pnpm install && pnpm run build && pnpm test pass and lint is clean.

A verifier agent is now checking it against the Definition of Done - build/test/lint, config strictness, Vitest alias resolution, .env.example containing no real token, .gitignore coverage, and scope discipline (no Mapbox code or endpoints added prematurely).

One thing to note: auto-commit is disabled for this workspace, so the scaffold changes are sitting uncommitted. Tell me if you want me to commit them.

Once verification passes I'll delegate the Mapbox client core task, which unlocks the three endpoint tasks as a parallel wave.

Ending my turn to wait for the verifier.

Add Animationslogistics-ai/app

Adding motion refinement to the app’s inventory dashboard.

GUI Overlay

Run pnpm build

Run git diff --check && git diff -- src/components/InventoryCard.astro

The page builds cleanly.

Managing external monitoring

Summary using controls

GUI Ready

A motion tuning panel is available top-right at http://localhost:4337.

It includes:

  • Click timing and scrub
  • Card reveal behavior
  • Reset and Copy JSON

The GUI is development-only and excluded from production builds.

Browser

01Electronics1,842962,240

02Motors68412864

03Hydraulics74254955

04Sensors1,261641,555

05Pneumatics1,120481,392

Animations browser panel

Every task is isolated in a workspace, so agents never step on each other. Kick one workspace off, line up the next, and work across hundreds of agents running in parallel without collisions.

Living Spec, aligned work.

A Coordinator agent writes a spec for every task, so each agent in a workspace works from the same plan instead of its own guess. That shared context keeps everyone aligned and becomes a running record of what was decided and why.

Full cycle, no babysitting.

Agents watch for changes and start the next task themselves. With git built in, commit, review, and merge happen in place, right next to your files and diffs, so whole workflows like PR review and CI checks run on their own.

Every task, right agent.

Out of the box, specialist agents like the Coordinator plan and delegate work. Under the hood, everything’s swappable: run your favorite CLI agents, mix them per workspace, and easily add your own custom agents.

Define what gets built, delegate to agents that stay aligned, and ship software that matches what you meant.