Lesson 7

Powers

The Problem Powers Solve

You learned in Lesson 5 that every MCP server you connect loads its tool definitions into context - potentially tens of thousands of tokens. Connect five servers and you've burned 40% of your context window before typing a word.

Powers solve this by making everything on-demand. A power bundles documentation + MCP servers + steering into a single package that only activates when you mention relevant keywords. Zero context cost until needed.

What a Power Contains

A power is a directory (usually in a GitHub repo) with this structure:

my-power/
├── POWER.md          # Required - metadata + instructions
├── mcp.json          # Optional - MCP server config
└── steering/         # Optional - additional steering files
    ├── workflows.md
    └── best-practices.md

Each piece serves a role:

The POWER.md File

This is the entry point - and the filename is a hard requirement, not just convention. It must be called exactly POWER.md (uppercase) at the root of the power directory. Kiro looks for this specific filename to identify a directory as a power.

It has YAML front-matter followed by markdown instructions:

---
name: "angular-patterns"
displayName: "Angular Patterns"
description: "Best practices and patterns for Angular development"
keywords: ["angular", "component", "service", "rxjs", "signal", "standalone"]
---

# Onboarding

When this power activates, ensure the project uses Angular 17+ with standalone components.

# Steering Instructions

You are an expert in modern Angular development. Follow these patterns:

## Workflow: Creating Components

1. Always create standalone components
2. Use signals for state management where possible
3. Prefer the inject() function over constructor injection
...

Front-matter Schema (Complete)

How Activation Works

Powers load dynamically based on your conversation:

1. You install a power (adds it to your Kiro config)
2. At rest, only the power's metadata (name + keywords) is loaded - negligible cost
3. When you mention a keyword in conversation (e.g. "angular" or "signal"), Kiro evaluates installed powers
4. If a power matches, its full content loads: POWER.md instructions, steering files, and MCP server connections

This is the key difference from raw MCP servers: with direct MCP config, tool definitions are loaded at all times. With powers, they load only when relevant.

Installing Powers

From the Powers panel

1. Open the Kiro sidebar (ghost icon)
2. Find the "Powers" section
3. Browse available powers from launch partners (Datadog, Figma, Netlify, Stripe, Supabase, etc.)
4. Click to install

From GitHub

1. In the Powers panel, click "Add power from GitHub"
2. Enter the repository (e.g. kirodotdev/powers)
3. Select the specific power from the repo

When you install a power that includes MCP servers, Kiro automatically registers them in your ~/.kiro/settings/mcp.json.

Available powers from launch partners

Browse the registry at kiro.dev/powers. Current partners include: Datadog, Dynatrace, Figma, Neon, Netlify, Postman, Supabase, Stripe, Strands SDK, AWS Aurora, ElevenLabs, Miro, and others.

Creating Your Own Power

Creating a power is straightforward - it's just a directory in a GitHub repo. Here's a practical example for your team:

Example: An Angular Library Power

angular-lib-power/
├── POWER.md
├── mcp.json
└── steering/
    └── component-api.md

POWER.md:

---
name: "our-angular-lib"
displayName: "Our Angular Component Library"
description: "Patterns and API docs for the team's shared Angular component library"
keywords: ["component library", "shared components", "ui-kit", "design system"]
---

# Onboarding

This power provides access to our team's Angular component library documentation.
The MCP server exposes tools for searching component APIs and usage examples.

# Steering Instructions

When working with components from our shared library (@our-company/ui-kit):

## Naming
- All components are prefixed with `app-`
- Services are suffixed with `.service.ts`

## Usage Patterns
- Import directly from the package: `import { ButtonComponent } from '@our-company/ui-kit'`
- All components are standalone - add to `imports` array directly
- Check the component API docs via the `search-components` tool before guessing props

mcp.json:

{
  "mcpServers": {
    "component-docs": {
      "command": "node",
      "args": ["/path/to/component-docs-mcp/dist/index.js"]
    }
  }
}

Powers vs Direct MCP vs Skills vs Steering

When to Use a Power vs. the Alternatives

• Use a power when you need tools + context + guidance bundled together, especially for a specific domain or technology
• Use raw MCP when you need the tools available at all times (e.g. GitHub, Jira - things you use every session)
• Use a skill when you need workflow instructions but no external tools
• Use steering when you need persistent background rules, not on-demand domain knowledge

How Powers Work Under the Hood

When a power activates:

1. Kiro loads the full POWER.md content into context (like a skill body loading)
2. Any steering files in the power's steering/ directory are injected into context
3. Any MCP servers defined in the power's mcp.json are connected (if not already running)
4. The MCP tool definitions from those servers are now available to the model

When the power deactivates (conversation moves to a different topic), the steering and tool definitions are unloaded. This is the context-efficiency win - you only pay for what you're using right now.

Your Tangible Win

You now understand what powers are, why they exist (context efficiency), how to install them, and how to create your own. You can make informed decisions about when to use a power vs. direct MCP vs. skills vs. steering. You also know the complete POWER.md schema and directory structure.

Quiz