25 Claude Code Agents I Actually Use
As an iOS Engineer
For a long time, my Claude Code prompts were basically the same shape every time: describe the bug, paste the file, ask for a fix.
It worked fine for small stuff.
It fell apart the moment the task got real a UIKit screen that needed to move toward Clean Architecture without breaking the rest of the module, or a performance pass on an image-heavy list that “feels slow” but has no obvious smoking gun.
The problem wasn’t Claude.
It was that a single ad-hoc prompt doesn’t carry any memory of how the work should be planned, constrained, or verified.
Every session, I was re-explaining the same things: inspect first, don’t break existing patterns, tell me what you changed, tell me how to verify it.
So I stopped writing one-off prompts for recurring work and started keeping a set of specialist agent briefs instead one per type of task, each with its own rules baked in.
This pack is 25 of them, and I’m giving it away free.
Why a Fixed Format Beats a Prompt List
A prompt asks for an output.
An agent defines how the work gets handled before, during, and after that output.
The format I settled on has five parts, and all 25 agents follow it:
Trigger is the one-line test for whether this is even the right agent it stops you from grabbing the Refactor Agent when what you actually need is the Performance Agent.
Mission is the single job the agent protects; everything it does should trace back to that one sentence.
Operating Rules is where the actual judgment lives how it reads the codebase, where it draws architectural boundaries, how it handles tradeoffs instead of guessing.
Output Contract fixes the shape of the final answer, so you’re not parsing a different format every time.
Quality Gates are the checks it has to clear before it’s allowed to call the work done.
Once you have that structure, the agent stops behaving like a chatbot and starts behaving like a teammate who already knows your conventions.
What’s Inside 25 Agents, 5 Categories
Foundation covers the agents I reach for before any of the others: Project Planning, iOS Clean Architecture, iOS Code Review, Refactor, and Python Quality.
These are the ones that decide how a piece of work should even be approached.
Mobile Specialists is the bulk of what I personally use day to day: SwiftUI Architecture, UIKit, UIKit MVVM, iOS Performance & Memory, plus Android Kotlin and React Native for the cross-platform work that occasionally lands on my desk.
Web, Backend & Data rounds out the stack for anything that isn’t strictly mobile:
Next.js Frontend, FastAPI Backend, PostgreSQL Database, Supabase Python, FastMCP Server, and an Agno Agent Expert for anyone building agent systems of their own.
Quality, Security & Ops is the unglamorous-but-necessary half: Test Automation, Security Audit, Kubernetes DevOps, and an Android Game C++ agent for native rendering work.
Product & Docs is the layer I actually lean on the most in a real production app Product iOS App,
Product Clean Code, Hybrid Mobile, and Technical Docs because generic best practices and your app’s actual conventions don’t always agree, and these agents are built to defer to the repo when they conflict.
The Ones I Run on Almost Every Project
As an iOS engineer, five of these get used constantly, not occasionally.
The iOS Clean Architecture Agent is the one I reach for whenever a screen has grown past “just put it in the view controller.” It forces a real separation between rendering,
state mapping, use cases, and external services and it won’t let business logic quietly creep back into the UI layer, which is exactly the failure mode that makes a codebase painful two years later.
The UIKit MVVM Agent and plain UIKit Agent cover the rest of my day-to-day, since most of my work sits in a mixed UIKit/SwiftUI codebase rather than a clean greenfield SwiftUI app.
The MVVM agent is strict about input/output contracts on the view model and keeps the view controller passive bind, render, forward actions which makes the result genuinely unit-testable instead of testable in theory.
The iOS Performance & Memory Agent is the one I trust the most precisely because it refuses to guess.
It wants a hypothesis and a measurement plan before touching anything Instruments, signposts, allocation checks and it optimizes the actual cause instead of papering over a symptom.
On an image-heavy screen, that discipline is the difference between a real fix and a fix that looks like it worked until the next device test.
The iOS Code Review Agent is what I run before almost anything gets merged.
It checks retain cycles, main-thread UI updates, async cancellation, and architecture drift, and it ranks findings by severity instead of dumping a wall of style nits which means I actually read the output instead of skimming past it.
How I Actually Run This
Every agent in the pack shares the same starter pattern, and it’s the part that matters more than any individual brief:
Before editing, inspect the relevant files and infer the existing patterns instead of assuming a fresh slate.
Flag the risks and write a short plan with a todo list for anything multi-step.
Implement only the scoped change no drive-by rewrites.
Close out with the files changed, the exact commands used to verify, the results, and whatever risk is still open.
That last part is the one most prompts skip entirely, and it’s the one that actually saves time, because you stop having to ask “wait, did this get tested?”
A bare-bones version of one brief looks like this once it’s pasted into Claude Code:
---
trigger: <when this agent is the right one to use>
mission: <the single job it protects>
---
[paste the full agent brief]
[add: repo path, architecture rules, banned patterns,
test/lint commands, and your definition of done]That last block repo path, architecture rules, your actual test commands is what turns a generic specialist into something that understands your app specifically, instead of giving you textbook iOS advice that ignores your team’s real conventions.
It’s Free
This pack is free, no email wall, no upsell page first.
⬇︎⬇︎⬇︎⬇︎⬇︎⬇︎⬇︎⬇︎⬇︎⬇︎⬇︎⬇︎⬇︎⬇︎
Grab it here: https://zerix1.gumroad.com/l/mzkcnd
⬆︎⬆︎⬆︎⬆︎⬆︎⬆︎⬆︎⬆︎⬆︎⬆︎⬆︎⬆︎⬆︎⬆︎
I’m planning a deeper, paid version down the line with project-specific walkthroughs and more niche stacks but this 25-agent set stays free regardless of that.
If you only try three, start with iOS Clean Architecture, UIKit MVVM, and iOS Code Review.
That’s the trio that’s saved me the most actual debugging time.
Written from real day-to-day Claude Code usage as an iOS engineer working in a mixed UIKit/SwiftUI codebase. If this was useful, follow me on Medium for more.
More developer resources and digital products: zerix1.gumroad.com
Thank you for reading! If you enjoyed it, please consider clapping and following for more updates! 👏
