Agentic coding in practice

Writing code with AI agents is not about writing better prompts; it is about setting up a clear workflow. When you move from a single chat window to using specialised agents, your job changes from writing code to directing it. Here is the workflow I use to go from an idea to shipped code.

April 20263 min read

I build Next Gig (opens in new tab), a tool for working musicians. To move faster as a designer, I started using coding agents. They help me build features quickly, but without strict boundaries, they can easily write messy code that is hard to maintain.

01 The multi-agent toolkit

I use Claude Code (opens in new tab) in the terminal for file editing, and Cursor (opens in new tab) to manage the local project.

To keep them on track, I use skills—short markdown files that tell the model about our codebase conventions before it starts:

sprint-ticket-review: Checks tickets against the codebase and adds the right file references before any edits.
push-to-paper: Keeps our React component styles synced with Paper (opens in new tab).
security-review: Scans auth and data paths before I merge a pull request.

02 From idea to production

Step 01

Pressure-test the idea

I brainstorm and challenge the concept first. Once it makes sense, I break the feature down into clear user stories.

Step 02

Add codebase context

I write the stories in Notion, then run sprint-ticket-review. The agent scans the code and adds relevant filenames, line numbers, and requirements to the ticket.

Step 03

Lock the ticket scope

I set strict boundaries. If a ticket is vague, the agent will guess, which leads to messy code. Every ticket needs clear constraints.

Step 04

Design first, or sync after

For new components, I design them in Paper first. For standard views, I write the code first and use push-to-paper to sync the visual design.

Try it yourself: the Paper skills (push-to-paper and three companions) are free to download. Drop them into ~/.claude/skills/ and run them on your own repo.

Step 05

Delegate the build

I assign tickets to Cursor and Claude Code. I act as the director—reviewing the code and testing the output—while the agents do the typing.

Strict contracts: Vague requirements invite agents to write unnecessary code. Treat every ticket as a contract.

Step 06

Run security audits

I run the security-review skill. This checks for auth gaps, unencrypted variables, or database rule issues.

Step 07

Test and deploy

I use a simple testing stack: Vitest for logic, Firebase emulators for DB rules, and Playwright for browser flows. I also use a separate agent to check the work, as fresh models catch assumptions the coding agent missed.

03 Practical takeaways

These four practices saved me the most development time:

Write clear tickets.

When tickets specify the codebase context, the agent's work merges easily. If they are vague, you waste time debugging.

Write automated tests.

Every time I skip writing tests to save time, I spend more time fixing bugs later. Automated tests keep the agent honest.

Use safety skills.

As a designer, I don't catch every backend auth edge case. Automated security checks fill that gap.

Standardise session context.

Pre-loading rules via reusable skills saves time. You don't have to explain the setup in every new chat.

This workflow is stable enough to ship production code. If you are building with agents, focus on setting clear boundaries and contracts, not on writing better prompts.