My 5 AI Coding Personas That Actually Work Susiloharjo

I’ve been using Antigravity daily for a few months now. At first, I treated it like a generic AI coding assistant — one chat, one personality, ask it everything. It worked, but the output was inconsistent. Sometimes brilliant, sometimes completely missing context.

Then I discovered you can configure specialized personas — dedicated agents with their own system prompts, objectives, and deliverables. I set up a handful of them. Each one does one thing well. Here are the five I actually use, with the prompts so you can copy them straight into Antigravity.

1. The Code Auditor

When I join a new codebase or inherit a legacy module, I don’t ask the generic assistant to “explain this code.” I switch to the Code Auditor. It reverse-engineers the architecture, maps data flows, and flags what’s wrong — duplicate logic, tight coupling, bottlenecks. It doesn’t touch the code. It just gives me a structured breakdown and a heatmap of problems.

I used this on a messy ERP module at work. It found three duplicate functions I hadn’t noticed in six months.

Here’s my system prompt:


You are a Senior Engineer joining a massive, unfamiliar codebase. Your job is to reverse-engineer the architecture, map complete data flows, and perform deep quality audits WITHOUT modifying any code. Identify: bad architectural choices, duplicate logic, performance bottlenecks, scalability risks, and long-term maintainability issues. Output: clean architecture breakdown, critical problem area heatmaps, explicit refactoring strategies.

2. The Debugging Specialist

Production bugs are different from dev bugs. There’s time pressure, incomplete logs, and a user waiting. This persona is tuned for step-by-step root cause analysis — input → code path → failure point → fix. No guessing.

I’ve used it twice for real incidents. Both times it found the exact line faster than I would have on my own, because it doesn’t get distracted by irrelevant code paths.

Here’s my system prompt:


You are a Debugging Specialist handling critical production outages. Step-by-step root cause analysis only. Track code execution, isolate failure mechanisms, and identify hidden edge cases. Do NOT guess. Output: code functionality breakdown, RCA (root cause analysis), failure explanation, edge-case mitigation matrix, and verified production-ready patch code.

3. The Performance Optimizer

Every few months, a query gets slow or a page takes 4 seconds to load. Instead of randomly adding indexes, I use this persona. It identifies high-cost operations, suggests caching strategies, and prioritizes fixes by impact.

Last time, it pointed out a PostgreSQL query doing a sequential scan on a table with 2 million rows. One index later: 400ms.

Here’s my system prompt:


You are a Senior Performance Engineer optimizing apps serving millions of concurrent users. Target: high-cost operations, memory leaks, suboptimal logic, and unnecessary rendering overhead. Deliver: performance bottleneck breakdown, systematic optimization strategies, high-throughput production code, and infrastructure scaling recommendations.

4. The Frontend Systems Agent

I’m stronger on the backend. When I need to build a UI component that handles loading, empty, error, and edge cases gracefully, I switch to this persona. It enforces strict prop APIs, responsive layouts, and accessibility.

My Angular components got noticeably cleaner after I started running them through this agent before committing.

Here’s my system prompt:


You are a Senior Frontend Engineer building enterprise-grade, accessible UI systems. Build scalable component architectures with extreme reusability and explicit state-handling. Gracefully handle: loading states, empty states, edge cases, responsive layouts, and accessibility (a11y). Output: component interaction architecture, strict Props/API design specs, implementation code, and integration examples.

5. The Clean Architecture Specialist

For refactoring days — when I need to break apart a God class or decouple a module without changing behavior. This persona enforces separation of concerns and gives me a new directory structure before writing a single line of code.

It’s not something I use daily. But when I need it, it saves hours.

Here’s my system prompt:


You are a Senior Software Architect rebuilding chaotic systems into clean, modular ecosystems. Refactor legacy codebases WITHOUT modifying product behavior. Enforce: separation of concerns, decoupled dependencies, predictable data flow. Output: new modular directory structure, clean architecture breakdown, decoupled refactored code, and architectural decision logs.

The pattern I’ve settled on: different agents for different phases. Auditor for understanding. Debugger for incidents. Optimizer for performance. Frontend agent for UI. Architecture specialist for refactoring. The generic assistant fills the gaps.

If you use Antigravity or similar tools that support custom personas, copy these prompts and give it a try. Start with two: the Code Auditor and the Debugging Specialist. You’ll notice the difference in the first session.

Discover more from Susiloharjo

Subscribe to get the latest posts sent to your email.