Agent Capabilities Showcase¶

The better-addons plugin is not a single AI assistant that tries to do everything. It is a team of nine specialized agents, each with focused expertise, specific tool access, and deep domain knowledge. When you issue a command like /wow-create or /wow-review, the right agent activates — and it may spawn additional agents to verify facts, research APIs, or review its own output before presenting results.

This page covers what each agent does, when to use it, what tools it has access to, and how the agents collaborate on complex tasks.

The Agent Architecture¶

Route and Delegate¶

The agent system follows a route and delegate pattern. The Generalist agent acts as the front door — it receives all unstructured requests, answers simple questions directly, and delegates complex work to the appropriate specialist. Each specialist is an expert in a narrow domain: the Coder writes code, the Reviewer reads code, the Debugger diagnoses problems, and so on.

This architecture exists because WoW addon development is not one skill — it is many. Writing a complete addon requires knowledge of the TOC file format, the Lua 5.1 sandbox, the frame system, the event model, the taint system, Secret Values, combat lockdown rules, and hundreds of C_ namespace APIs. Reviewing an addon requires a different lens: security awareness, performance analysis, deprecated API detection, and Midnight compatibility checks. Debugging requires symptom categorization and root cause analysis. No single prompt can encode all of this well. Specialized agents can.

Agent Spawning¶

Agents can spawn sub-agents during their work. When the Coder needs to verify an API signature it is not certain about, it spawns a Researcher sub-agent to look it up on warcraft.wiki.gg. When the Migrator needs to rewrite a file, it may spawn the Coder to generate the replacement. When the News Desk needs to cover five topics simultaneously, it spawns five parallel research agents. This delegation happens automatically — you do not need to orchestrate it.

Tool Access Control¶

Each agent has a specific set of tools. The Reviewer has no write access — it cannot modify files, only read and report. The Researcher can search the web but cannot edit code. The Coder can write files but does not search the web directly (it delegates that to a Researcher). This separation enforces correctness: a review agent that could silently "fix" what it finds would defeat the purpose of a review.

Mode Awareness¶

Every agent reads the active development mode before starting work. If the mode is set to blizzard-faithful, the Coder will refuse to use hooksecurefunc on Blizzard frames. If the mode is performance-zealot, the Reviewer will flag unthrottled OnUpdate handlers as critical issues. If the mode is boundary-pusher, the Scaffold will generate metatable hook boilerplate. The mode is a project-wide setting that shapes all AI behavior consistently.

The Nine Agents¶

Generalist — The Router¶

The Generalist is the entry point for all unstructured questions and requests. It contains extensive inline knowledge about the WoW 12.0 addon landscape — the state of major addons, the Better addon ecosystem, Secret Values behavior, and common development patterns. For simple questions, it answers directly. For complex tasks, it identifies the right specialist and delegates.

The Generalist knows the current state of major addons — which ones have migrated to 12.0, which are abandoned, which have forked. It knows the Better addon ecosystem (BetterBlizzFrames, BetterBlizzPlates, BetterAddonList) and can explain their patterns. It also understands development modes and will tailor architectural recommendations to the active mode.

What's the current status of WeakAuras in Midnight?

Coder — The Builder¶

The Coder is the largest and most complex agent in the system. Its agent definition is 39KB — a complete WoW addon development specification baked into a single prompt. It contains the full TOC file format, Lua environment reference, event system documentation, frame and widget API, C_ namespace specifications, Secret Values rules, Settings API patterns, Addon Compartment setup, ScrollBox/DataProvider usage, build and release workflows, and a 16-item pre-submission verification checklist.

The Coder writes complete, production-ready addon code — never snippets, never placeholders, never "TODO" comments. Every addon it generates includes a properly structured TOC file, namespace pattern in every Lua file, event dispatch tables, combat lockdown awareness, and Secret Values handling. The code can be dropped directly into Interface/AddOns/ and loaded by the game client.

Anti-Hallucination System¶

The Coder's most distinctive feature is its anti-hallucination guide — explicit tables of functions that do not exist in WoW's Lua environment but that AI models commonly generate:

It also includes a deprecated function mapping — 17 functions that existed in previous expansions but were removed or replaced in Midnight, with their correct modern equivalents.

/wow-create a poison reminder for rogues that warns when poisons are missing

Reviewer — The Critic¶

The Reviewer is a read-only agent. It cannot modify files — it can only read code and produce structured reports. This constraint is intentional: a code review should identify problems, not silently fix them. The developer decides what to act on.

The Reviewer uses a structured severity system with three tiers:

• CRITICAL — Will cause errors, crashes, or security issues (deprecated APIs, missing combat lockdown checks, Secret Values violations)
• WARNING — Will cause problems in specific scenarios (missing event unregistration, potential taint, performance issues)
• STYLE — Code quality and convention issues (missing namespace pattern, global variables, non-standard event handling)

Every finding includes a file path, line number, explanation of the problem, and a suggested fix. The final report includes an overall grade from A (no issues) to F (critical problems throughout).

/wow-review

## Code Review: MyAddon

### CRITICAL
- Core.lua:47 — Uses `GetSpellInfo()` (deprecated).
  Use `C_Spell.GetSpellInfo(spellID)` instead. Returns a
  SpellInfo table, not multiple values.
- Core.lua:112 — Arithmetic on `UnitHealth("target")` without
  `issecretvalue()` check. Will error during M+/PvP/encounters.

### WARNING
- Core.lua:89 — `ADDON_LOADED` handler does not call
  `self:UnregisterEvent("ADDON_LOADED")` after initialization.
- UI.lua:34 — `frame:SetScript("OnUpdate", ...)` without
  elapsed throttle. Fires every frame (60-240+ Hz).

### STYLE
- Config.lua:1 — Missing `local addonName, ns = ...` namespace
  pattern.

Overall Grade: C
3 files reviewed | 2 critical | 2 warnings | 1 style

Debugger — The Detective¶

The Debugger diagnoses addon issues through symptom categorization. When you describe a problem, it classifies the symptom into one of nine categories and applies the corresponding diagnostic procedure. It does not guess — it reads your code, identifies the root cause, and explains both the problem and the fix.

The nine symptom categories are:

1. Taint errors — "Action blocked" messages, secure frame interference
2. Secret Values problems — Arithmetic errors that only appear in combat/M+/PvP
3. Event failures — Events not firing or firing with unexpected payloads
4. Frame bugs — Frames not appearing, incorrect positioning, visual glitches
5. Combat lockdown violations — Protected operations attempted during combat
6. Communication failures — Addon messages blocked in instances
7. SavedVariables corruption — Data not persisting or loading incorrectly
8. Performance issues — Memory leaks, FPS drops, excessive garbage collection
9. Load failures — Addon not appearing in the addon list, TOC errors

/wow-debug my addon works fine in the open world but throws
errors as soon as I enter a Mythic+ dungeon

Migrator — The Translator¶

The Migrator converts pre-12.0 addons to Midnight compatibility through a six-phase migration pipeline. It does not just find-and-replace deprecated functions — it understands the semantic differences between old and new APIs and rewrites code to handle the structural changes (functions that returned multiple values now return tables, events that carried payloads now carry secret values, etc.).

The six phases are:

1. TOC Update — Interface number to 120001, add Category/Group fields, add AddonCompartment declarations
2. API Replacements — Deprecated function calls replaced with C_ namespace equivalents, with return value destructuring updated
3. CLEU Migration — COMBAT_LOG_EVENT_UNFILTERED handlers rewritten to use unit events (UNIT_HEALTH, UNIT_AURA, UNIT_SPELLCAST_SUCCEEDED)
4. Secret Values — All combat data access paths guarded with issecretvalue() checks and widget-safe fallbacks
5. Communication — Addon message sends wrapped with InChatMessagingLockdown() checks, queue-and-flush pattern added
6. Validation — Final pass checking for remaining deprecated calls, missing guards, and Midnight anti-patterns

/wow-migrate

## Migration Report: OldAddon

### Phase 1: TOC Update
- Updated Interface: 110002 -> 120001
- Added: ## Category: Combat
- Added: ## AddonCompartmentFunc: OldAddon_OnAddonCompartmentClick

### Phase 2: API Replacements (7 found)
- Core.lua:23 — GetSpellInfo(id) -> C_Spell.GetSpellInfo(id)
  NOTE: Return value changed from multiple values to SpellInfo table.
  Updated destructuring: name = spellInfo.name, icon = spellInfo.iconID
- Core.lua:89 — EasyMenu(menuList, ...) -> MenuUtil.CreateContextMenu(...)
  NOTE: Complete rewrite required. Menu structure converted.
...

### Phase 3: CLEU Migration
- Removed COMBAT_LOG_EVENT_UNFILTERED handler (47 lines)
- Added UNIT_HEALTH handler for health tracking
- Added UNIT_AURA handler for debuff tracking
- Added UNIT_SPELLCAST_SUCCEEDED handler for cast detection

### Phase 4: Secret Values Guards
- Added issecretvalue() checks at 4 locations
- Added widget-safe fallback paths for StatusBar updates

6 phases complete | 23 changes | 0 manual review items

Researcher — The Verifier¶

The Researcher finds and verifies WoW API documentation. It does not trust its own training data — it actively searches warcraft.wiki.gg, GitHub repositories, and Blizzard blog posts to confirm API signatures, return values, event payloads, and behavioral details. Every piece of information it returns carries a confidence label.

The confidence labels are:

The Researcher uses a swarm pattern — when researching a complex topic, it spawns 3-4 parallel sub-agents that each search different sources simultaneously, then consolidates their findings with cross-referenced confidence scores.

/wow-research C_EncounterEvents namespace — what functions exist and how do they work?

:material-scaffold: Scaffold — The Architect¶

The Scaffold creates complete project structures from scratch. It generates not just code files but the entire development environment — TOC file, Lua source files, .pkgmeta for CurseForge/Wago packaging, .luacheckrc for linting, GitHub Actions release workflow, and optionally a CLAUDE.md file for AI-assisted development.

The Scaffold offers three tiers of project complexity:

The Scaffold is mode-aware. In blizzard-faithful mode, it generates conservative boilerplate with Settings API and Addon Compartment. In boundary-pusher mode, it includes metatable hook boilerplate and taint isolation patterns. In performance-zealot mode, it generates local caching blocks, object pool boilerplate, and a /perf diagnostic slash command.

/wow-create standard tier addon called "RaidCallouts" for encounter alerts

RaidCallouts/
  RaidCallouts.toc          -- Interface: 120001, Category: Boss Encounters
  Init.lua                  -- Namespace setup, defaults table, constants
  Core.lua                  -- Event dispatch, ENCOUNTER_START/END handling
  UI.lua                    -- Alert frame creation, positioning, animations
  Config.lua                -- Settings API panel, sound/visual toggles
  .pkgmeta                  -- CurseForge/Wago packaging config
  .luacheckrc               -- Lint config with WoW globals
  .github/workflows/release.yml  -- Tag-triggered release pipeline

Skin Designer — The Artist¶

The Skin Designer specializes in UI enhancement addons — addons that modify the visual appearance of Blizzard's existing frames without replacing them. It is the agent that best understands the "enhance don't replace" philosophy and the specific techniques required to skin frames safely in Midnight.

The Skin Designer knows eight core skinning techniques:

1. StripTextures — Iterate GetRegions(), reparent textures to a hidden frame
2. ApplyBackdrop — Mixin BackdropTemplateMixin, apply flat backdrop with pixel borders
3. hooksecurefunc post-hooks — React to Blizzard function calls without overriding them
4. HookScript — Add behavior to Blizzard frame scripts without replacing handlers
5. Mixin extension — Add custom methods to Blizzard frame instances
6. Edit Mode integration — Hook EditModeManagerFrame enter/exit events
7. ScrollBox skinning — Hook OnDataRangeChanged to skin dynamically created list elements
8. Secret Values-safe StatusBar hooks — Apply visual modifications (class colors, gradients) without reading the bar's value

Make the player frame look modern — flat dark background, class-colored health bar,
remove the portrait and dragon frame decorations

News Desk — The Reporter¶

The News Desk provides real-time addon ecosystem intelligence. It searches the web for the latest news about WoW addon development — Blizzard API announcements, addon updates, community controversies, new addon releases, and ecosystem trends. It uses a swarm pattern, spawning up to five parallel research agents that each cover a different angle of the requested topic.

The five swarm agents typically cover:

1. Official sources — Blizzard blog posts, blue tracker, hotfix notes
2. Addon platforms — CurseForge, Wago, WoWInterface trending/updated
3. Community discussion — Reddit r/wow, r/wowaddons, WoW forums
4. Developer activity — GitHub commits, pull requests, release tags on major addon repos
5. Content creator coverage — YouTube, Twitch clips, blog posts about addon changes

/wow-news what's happening with bag addons in Midnight?

Agent Interactions¶

The agents do not work in isolation. Complex tasks trigger multi-agent workflows where specialists collaborate through spawning and delegation.

The Verification Loop¶

When the Coder writes addon code, it may encounter an API it is not fully certain about — perhaps a newer function added in 12.0.1 that was not in its training data, or a function whose return value structure changed between expansions. Rather than guessing, the Coder spawns a Researcher sub-agent to verify the API against warcraft.wiki.gg and real addon source code. The Researcher returns a confidence-labeled answer, and the Coder uses only CONFIRMED or CORROBORATED information in the generated code. This verification loop is why the Coder rarely hallucinates API calls — it checks its work automatically.

The Review Cycle¶

A natural development cycle emerges across three agents:

1. Coder generates the addon code
2. Reviewer examines the code and produces a structured report with severity-graded findings
3. Debugger investigates any runtime issues discovered during testing
4. Coder applies fixes based on the Reviewer's and Debugger's findings

You can run this cycle manually by issuing /wow-create, then /wow-review, then /wow-debug if issues arise. Each agent operates independently — the Reviewer does not know what the Coder intended, it only evaluates what the Coder produced. This independence prevents confirmation bias.

The Migration Pipeline¶

Migrating a pre-12.0 addon to Midnight is the most agent-intensive workflow:

1. Migrator analyzes the existing codebase and identifies all deprecated APIs, CLEU usage, missing Secret Values guards, and communication patterns
2. Researcher verifies the correct replacement APIs for each deprecated function, confirming they exist and work as documented in 12.0
3. Coder rewrites complex sections that require structural changes (CLEU handlers converted to unit event handlers, EasyMenu converted to MenuUtil, InterfaceOptions converted to Settings API)
4. Reviewer validates the migrated code against Midnight compatibility requirements

This pipeline ensures that migrations are not just mechanical find-and-replace operations but semantic transformations that account for the structural differences between old and new APIs.

Agent Comparison Table¶