home / skills / falkicon / mechanic / s-develop

s-develop skill

needs review

This skill helps you design World of Warcraft addons with event-driven patterns, SavedVariables, and resilient APIs using Ace3.

npx playbooks add skill falkicon/mechanic --skill s-develop

Review the files below or copy the command above to add this skill to your agents.

Files (6)

SKILL.md

2.8 KB

---
name: s-develop
description: >
  Core WoW addon development patterns using Ace3 framework and Blizzard UI APIs.
  Covers event-driven design, SavedVariables, frame architecture, and API resilience.
  Use when building addons, designing systems, or integrating libraries.
  Triggers: addon, WoW, Lua, Ace3, frame, event, SavedVariables, architecture.
---

# Developing WoW Addons

Expert guidance for building World of Warcraft addons with a focus on testability and maintenance.

## Related Commands

- [c-develop](../../commands/c-develop.md) - Build or extend addon features workflow

## CLI Commands (Use These First)

> **MANDATORY**: Always use CLI commands before manual exploration.

| Task | Command |
|------|---------|
| Create Addon | `mech call addon.create -i '{"name": "MyAddon"}'` |
| Sync Junctions | `mech call addon.sync -i '{"addon": "MyAddon"}'` |
| Validate TOC | `mech call addon.validate -i '{"addon": "MyAddon"}'` |
| Check Libraries | `mech call libs.check -i '{"addon": "MyAddon"}'` |
| Sync Libraries | `mech call libs.sync -i '{"addon": "MyAddon"}'` |

## Capabilities

1. **Event-Driven Design** — Register events, handle callbacks, bucket patterns
2. **Frame Architecture** — Three-layer design (Core/Bridge/View), layouts, templates
3. **SavedVariables** — Database design, AceDB, versioning, defaults
4. **Combat Lockdown** — Protected functions, taint avoidance, secure handlers
5. **API Resilience** — Defensive programming, C_ namespaces, secret values

## Routing Logic

| Request type | Load reference |
|--------------|----------------|
| Addon architecture, layers | [../../docs/addon-architecture.md](../../docs/addon-architecture.md) |
| Event registration, callbacks | [references/event-patterns.md](references/event-patterns.md) |
| Frame creation, UI engineering | [references/frame-engineering.md](references/frame-engineering.md) |
| SavedVariables, AceDB | [references/saved-variables.md](references/saved-variables.md) |
| Combat lockdown, secure code | [references/combat-lockdown.md](references/combat-lockdown.md) |
| Blizzard API, C_ namespaces | [references/api-patterns.md](references/api-patterns.md) |
| MechanicLib integration | [../../docs/integration/mechaniclib.md](../../docs/integration/mechaniclib.md) |
| Performance profiling | [../../docs/integration/performance.md](../../docs/integration/performance.md) |

## Quick Reference

### Create New Addon
```bash
mech call addon.create -i '{"name": "MyAddon", "author": "Name"}'
mech call addon.sync -i '{"addon": "MyAddon"}'
```

### Core Principles
1. **Headless Core**: Keep logic in pure Lua functions (Layer 1)
2. **Event-Driven**: Avoid `OnUpdate` polling; use events (Layer 2)
3. **Defensive API**: Always check for `nil` and use `pcall` for uncertain APIs
4. **Combat Aware**: Never modify protected frames in combat

Overview

This skill teaches core World of Warcraft addon development patterns using Ace3 and Blizzard UI APIs. It focuses on maintainable, testable architecture, event-driven design, SavedVariables management, and resilient API usage. Use it to build robust addons that behave safely in combat and under changing game APIs.

How this skill works

I guide you through a three-layer frame architecture (Core/Bridge/View), event registration patterns, and AceDB-backed SavedVariables. The skill shows defensive techniques for calling Blizzard C_ namespaces, avoiding taint, and designing secure handlers for combat lockdown. It also centralizes debugging, error capture, and performance monitoring practices for in-game testing.

When to use it

Starting a new addon or refactoring an existing one
Designing frame layouts and UI templates with layer separation
Implementing event-driven features and reducing polling
Integrating Ace3 libraries and AceDB for SavedVariables
Hardening code against API changes and combat lockdown

Best practices

Keep logic in a headless core (pure Lua) and separate UI code into bridge/view layers
Prefer event registration and bucket patterns over OnUpdate polling
Use AceDB for SavedVariables with explicit defaults and version upgrade paths
Wrap uncertain API calls with pcall and validate C_ namespace returns before use
Avoid modifying protected frames while in combat; use secure handlers and attribute-driven updates
Centralize error capture and lightweight profiling for reproducible bug reports

Example use cases

Build a buff/debuff tracker using events and a view layer for frames
Create a settings panel backed by AceDB with migration logic between versions
Instrument addon startup and runtime with lightweight performance hooks for slow-path detection
Integrate a third-party library safely by validating library versions and syncing junctions
Implement secure click handlers and attribute templates that survive combat lockdown

FAQ

How do I structure SavedVariables to support upgrades?

Use AceDB with a clearly versioned defaults table, run a migration step on load that checks db.version and applies transformations before use.

When should I use pcall versus explicit nil checks?

Use explicit checks for expected nils and structural validation; reserve pcall for calls to APIs that may throw or for optional libraries where failures are acceptable.