JGJonathan Gobielweb platform engineer
Back

AI development efficiency

Leveraging AI for Day-to-Day Dev Efficiency: Prompts, Context, Specs, and Small Verifiable Tasks

productivitypromptscontextverification
4 min read

Loop engineering gets the headlines. Most of my weekly speed still comes from boring discipline: what I put in the prompt, what context the agent sees, and how small I cut the task.

I work on a mobile fintech H5 stack (React, TypeScript, heavy shared UI). These habits transfer to Vue or other frameworks. They are about verifiability, not vendor hype.

Stop Prompting Like a Search Box

Ad-hoc prompts work for "how do I parse this date in TS." They fail for multi-file work because the model fills gaps with plausible structure.

I use a prompt contract on anything that touches more than two files:

Objective: Add skeleton state to transaction list
Scope: packages/wallet/TransactionList.tsx, packages/ui/Skeleton.tsx
Constraints: No API changes; keep virtualized list behavior
Done when: pnpm test wallet --run passes; storybook snapshot unchanged
Verification: pnpm lint && pnpm test wallet --run

Two minutes to write. Saves two review rounds. The Scope line matters most. Without it, agents "helpfully" refactor neighbors.

Context: Less Noise, More Signal

Agents do not need your entire monorepo. They need:

  • files in scope,
  • interfaces they must not break,
  • one example of the pattern you want copied,
  • the command that proves success.

I keep a short AGENTS.md at repo root with folder purposes, test commands, and forbidden moves (e.g., no new animation deps in critical path). Agents read it every session.

For terminal-heavy work, compressing command output before it hits the model context helped me enormously in earlier experiments (on the order of ~80% fewer tokens from shell noise in a single session when using tools like RTK-style wrappers). Cleaner context beats a bigger context window.

Specs Before Code, Even When the Spec Is Tiny

Ambiguous tickets are where AI burns the most calendar time. My minimum spec:

  • user-visible outcome,
  • edge cases (empty, error, loading),
  • analytics or logging events if any,
  • non-goals.

The solution-architecture agent expands that for large work. For small work, a five-bullet comment on the ticket is enough.

If the spec says "improve performance," the agent will shuffle imports. If it says "reduce LCP image bytes without changing hero crop," you get WebP and preload work that matches real wins we have shipped before.

Small Verifiable Tasks Beat Hero Tasks

Hero tasks: "rebuild checkout." Agent produces 2,000 lines, tests lag, review collapses.

Verifiable slices:

  1. Extract pure pricing function + unit tests.
  2. Wire UI to function behind flag.
  3. Add Maestro smoke for happy path only.

Each slice has one verification command. Loops can retry slices independently.

This mirrors how I got ~90% faster dev build iteration at a previous employer (Tokopedia-era platform work): shrink the feedback unit until the build tells you the truth quickly. AI no different.

Tools I Actually Use Outside the Editor

Route inspector CLI (internal): agents dump registered routes and guards before touching navigation.

Module scaffolder CLI (internal): consistent folder layout so review agents stop arguing about structure.

Mention bots that answer "which PR is for ticket X?" so I do not context-switch to GitHub.

Side projects taught the same lesson: my AI video clipper and expense summarizer shipped because tasks were file-bounded with ffmpeg or API commands as verification, not because the model was magic.

Pairing AI With Human Strengths

AI is strong at:

  • boilerplate with clear types,
  • test case expansion from examples,
  • summarizing long diffs,
  • translating error logs into hypotheses.

AI is weak at:

  • product tradeoffs you have not written down,
  • novel cross-service outages,
  • judging whether animation delay feels right.

I default AI to the first list and keep the second for me or a product partner.

Daily Session Template

  1. Pull ticket → write prompt contract.
  2. Paste contract + relevant AGENTS.md excerpt.
  3. Let agent implement; run verification locally or in CI.
  4. If red, paste only failing output, not whole logs.
  5. Human read for risk-tagged files; merge or send back.

Fifteen-minute standups improved because status is "slice 2 verification red on test X," not "still working on checkout."

FAQ

Do I need special models?

Workflow structure mattered more than model swaps for me. Fix scope and verification first.

How do I avoid review debt?

Same as human juniors: small PRs, mandatory verification, reviewers tuned for signal (see my PR review post).

What about privacy?

No production secrets in prompts. Redact logs. Use preview environments.

Can AI write the spec?

It can draft. Human confirms non-goals and edge cases before implementer starts.

Closing

Pick one task tomorrow, write a four-line contract, and refuse to accept agent output until the verification command passes without you fixing the diff.

That habit scales into full loop engineering later. It already pays today.