Skip to main content

What is Power

Power is a content-agnostic stat and effect system for Unity. You assemble stat-driven mechanics by connecting assets in the Inspector, with little or no custom code.

Power is User Friendly

  • Create game mechanics by connecting Power assets.
  • Most mechanics can be built without writing custom code.

Power is AI Ready

  • Mechanics are assets, so AI agents can build them too.
  • power-skill works with Claude Code, Codex and more.

Power is Stat Agnostic

  • There are no predefined stats in Power.
  • A Stat's purpose and behavior are fully defined by the user through its relationships.

Power is Effect Centric

  • Power does not just support primitive stats like float and int.
  • It provides a variety of useful stat types to enable complex effects.

Power Minds Its Own Business

  • Power does not force you to use its systems across your entire game.
  • It operates within a well-defined scope, allowing you to extend it freely in your own game logic.

Power Supports Both Turn-based and Real-time Systems

  • This is mainly about pacing, and Power supports both approaches.
  • You can even combine both if you want.

How it fits together​

Power's runtime flow has five elements: Actor, Stat, Effector, Effect, and Processor.

Effector
applies
Effect
through
Processors
modifies
Actor
Stats

An Effect targets a Target Stat and can carry Attribute Stats that define its behavior or classification. As the Effect passes through the Processor funnel, relationships defined on those Stats — such as modifiers, immunities, limits, and reflections — can shape, modify, or block the result before it is applied.

Is Power for you?​

Power is for you if you want to design your game with ready-made, detailed building blocks instead of having to implement complex stat and effect mechanics from scratch.

Games Power is good for:​

  • Action RPGs
  • JRPGs
  • Tactics / SRPGs
  • Roguelikes & roguelites
  • Looter shooters
  • Tower defense
  • Survival & crafting
  • City & management sims
  • Idle & incremental games
  • Visual novels

Every game has stats and ways for players to change them. That interaction is exactly what Power focuses on, making it a strong fit for genres built around numbers, stats, and the rules connecting them

See it in action​

  • 3DCells — a real-time action demo with 15 weapons and a shield: conditional crits, status effects, charge mechanics, multi-state Skills, collision Effects.
  • Kodes — a real-time roguelite with 39 upgrades, many built with AI.
  • Slay The Sphere — a turn-based card game: 20 cards, 7 relics, 3 potions.
  • General Expansions — collision-based Effectors and the Skill system, with source you can adapt.

Why you should still use Power in the AI era​

AI agents write code fast, so why use a framework at all? Because writing a mechanic is only the start. The hard part comes later: finding out why a hit dealt the wrong number, adding the 40th upgrade without breaking the other 39, and tuning everything until it feels right. Power is built for that part.

Every mechanic is visible​

AI-written code grows a little differently with every request: one more damage path, one more status check, one more special case. After a few dozen features, nobody knows exactly what happens on a hit, not even the agent that wrote it.

In Power, a mechanic is a set of connected assets, and you can see all of it:

  • Relations draws a mechanic as a graph: which Stats and Effects it uses and what uses them.
  • Flow traces a single Effect through the pipeline at runtime: every Processor it passed and what each one changed.
  • Search and Access take you to the asset you need in a click.

Bugs are caught before you press Play​

  • Validator checks every asset, prefab and scene and points at each broken Key, missing reference and misplaced Processor.
  • Orphans finds what nothing uses anymore after an experiment or a rename.
  • Your agent runs the same checks after every mechanic it builds, so a wiring mistake shows up as an error line, not as a strange bug three upgrades later.

One pipeline, so features don't collide​

Every Effect, from the first upgrade to the hundredth, goes through the same Processor pipeline with the same rules for order, stacking, immunity and ownership. New mechanics plug into rules that already work instead of inventing new ones, so interactions stay predictable as the game grows. That's the point where hand-written AI code usually gets hard to manage: each new feature has to be checked against every old one.

Change it without rewriting it​

  • Tune in the Inspector. Numbers, durations, chances and conditions are data. You, a designer or a tester can change them without touching code or waiting for a compile.
  • Swap the rule, keep the rest. Turning "+20 % damage" into "+20 % damage to isolated foes" is a different Modifier on the same Stat, not a refactor.
  • Ask the agent for the change, not the code. With power-skill, you describe the new behaviour and the agent rewires the assets. You review the result in the same tools you'd use yourself.

The agent builds with known pieces​

Agents follow structure well. With Power, an agent doesn't design a stat system, a damage pipeline and a status system before it can build your first upgrade; those already exist and are documented. It turns your request into a Power formula and builds it from the same pieces every time, so the result is something you can read, check and change in the same tools.

Build once, reuse everywhere​

The same engine runs a real-time roguelite, a turn-based card game, an action demo and a visual novel. What you and your agent learn on one game carries over to the next.

In short: AI makes writing gameplay fast. Power makes that gameplay easy to debug, improve and change for the rest of the project's life.