Codegarden

Don’t miss Umbraco’s event of the year

Get your ticket →

The Agent-Ready CMS: Introducing Agent Skills: Umbraco Backoffice Extension

Phil Whittaker
Written by Phil Whittaker

In the first episode of this blog post series, we defined Agent Skills. Now, it’s time to talk about how we support Agent Skills from Umbraco HQ, and the opportunities it brings to your business as a partner or end client working with Umbraco. In this post, you also find out how to actually get started using Agent Skills and Umbraco, so if you’re a developer - or know someone in your team - eager to play, this post is for you.

We’re seeing a fundamental shift in how digital projects are delivered. AI isn’t just a “helper” anymore; it’s becoming the primary starting point for new projects and where developers explore. We want to ensure Umbraco is an Agent-Ready CMS, meaning that when your team reaches for an AI assistant, the right Umbraco knowledge is already there, available in the tools they use the most.

Imagine being able to use the Backoffice Extension Agent Skill to:

  • Turn a client’s idea into a working wireframe in hours, not days, to validate concepts early.

  • Upgrade older extensions to the modern backoffice using the latest patterns instead of guessing.

  • Use it as a digital "senior developer" to help your team master new patterns while they actually build.

Here's how it works and why it matters for Umbraco developers and your business.

What Are Agent Skills?

Agent Skills act as a helping hand for AI coding tools. These specific skills are designed to provide AI with structured, up-to-date knowledge and best practice on how to create extensions for the Umbraco backoffice.

Think of them as expert guides that sit alongside your AI assistant. When you ask your AI to build a dashboard, a custom section, or a property editor, the relevant skill is loaded into context and gives the AI everything it needs: the concepts, the patterns, working code examples, and links to official documentation.

Learn more about what Agent Skills are in our previous blog post, The Agent-Ready CMS: What are Agent Skills?

The Problem Agent Skills Solve

AI is probabilistic. It learns from everything it's seen, and there's a lot of content out there about Umbraco; articles, tutorials, and documentation spanning versions 8-13, 14, 15, 16, and 17.

When you ask an Agent to build a backoffice extension without guidance, it might have a good stab at it. But it will often:

  • Mix patterns from different Umbraco versions

  • Use deprecated APIs or outdated component names

  • Maybe even try to write AngularJS!?!!

These skills help to reduce that problem by giving the AI the right information at the right time.

What We're Aiming For with CMS Backoffice Skills

This project has several goals:

  1. Help people learn how the backoffice works. Each skill contains details, documentation, and working examples that demonstrate real patterns. You can ask the AI to explain how the code works, walk you through the patterns, and clarify why things are done a certain way. It's documentation that actually runs with an expert on hand to explain it.

  2. Pair programming with your AI assistant. These skills aren't only about generating code for you; they're about creating extensions together. Load the umbraco-backoffice skill, describe what you want to build, and the Agent will guide you through the process step by step. You stay in control while learning as you go. It's pair programming with a partner who knows the Umbraco backoffice inside out.

  3. Enable rapid prototyping. Got an idea for a custom admin area? A data management tool? A hierarchical content browser? These skills help you go from concept to working prototype quickly.

  4. Assist with upgrades. Whilst there are no skills specifically for the AngularJS backoffice, the detailed descriptions of what each extension type does and how it should behave can help when upgrading. Describe your existing extension, provide specs or even screenshots, and let the AI help you rebuild it with the latest patterns.

How The Umbraco Backoffice Skills Work

The skills are organised as a collection, with over 66 individual skills covering many different aspects of backoffice development. This grouping matches the documentation for extension types in the Umbraco backoffice.

Each skill provides:

  • A brief description of what the extension type does and when you'd use it

  • The fundamentals of how it works within the backoffice architecture

  • Code examples showing minimal implementations

  • Links to official Umbraco documentation for deeper detail

The key design principle is progressive discovery. Only the skills needed for your current task are loaded into the AI's context. When a skill is loaded, it contains links to related skills and other documents that provide more information as and when the AI needs it.

This matters because AI models have limited context windows. Loading everything at once would overwhelm the context and degrade quality.

The key is: Only what's needed, when it's needed.

By loading information progressively, the AI can maintain focus and produce better results.

The Umbraco Backoffice Routing Skill

At the heart of the collection is a routing skill called umbraco-backoffice. This is the "big picture" skill that explains how the backoffice works and how all the pieces fit together. It also routes down to relevant sub-skills for specific implementation.

It relates to a crucial concept: backoffice customisations are combinations of extension types. For example:

  • A custom admin area = Section + Menu + Dashboard

  • A data management tool = Section + Menu + Workspace

  • A hierarchical browser = Section + Menu + Tree + Workspace

The skill includes an extension map showing where all 40+ extension types appear in the backoffice UI. This helps it to understand what it's building and where everything will appear.

Most importantly, this skill contains fully working, runnable, and tested examples. These aren't snippets - they're complete extensions you can build and run. The AI can reference these examples to validate its output against known-good implementations.

How to set up the Backoffice Extension Agent Skills.

The Quickstart Experience

The umbraco-quickstart skill wraps everything into a guided, end-to-end workflow.

Run it with a single command in Claude: /umbraco-quickstart MyUmbracoDemoSite MyExtension

Here's what happens in this workflow:

  1. Creates an Umbraco instance using the Package Script Writer CLI - a working Umbraco installation ready for development.

  2. Creates an extension project using the official dotnet template, with TypeScript, Vite, and all the tooling configured.

  3. Joins them together by adding project references and registering the extension.

  4. Enters planning mode where the AI asks questions about what you want to build.

  5. Creates a plan document with ASCII wireframes showing the proposed UI, lists of extension types to be used, and the components needed. This is presented for your review and approval. You can change anything that doesn't look right at this point.

  6. Builds the extension using the appropriate sub-skills, generating manifests, elements, and any supporting code.

  7. Reviews against known issues using an automated reviewer that checks for common mistakes - wrong element names, missing registrations, incorrect context usage.

  8. Validates in the browser by actually driving Umbraco in Chrome and testing the extension as a developer would - clicking through the UI, checking that things appear where they should, verifying functionality works.

Watch the building of a custom Github Picker using Umbraco QuickStart Skill.

Validation Is Key

We've found that although these skills are good, they will still make mistakes. AI is non-deterministic, and even with excellent guidance, things can go wrong.

But here's where modern AI capabilities shine.

Because current models support long-running sessions, agents can stay on track and iterate on problems. When the reviewer finds an issue, the AI can fix it. When browser validation reveals a problem, the AI can debug it. The process continues until all requirements are satisfied.

This is a fundamental shift from "generate code and hope" to "generate, validate, and refine." The quickstart skill is designed to support this workflow, with clear validation checkpoints built in.

Open Source Superpower

These skills work best when the AI is also connected to the Umbraco source code and the Umbraco UI component library. This is just another layer of progressive discovery.

This is a superpower of Umbraco, it's open source and available. When the AI needs to understand how a particular component works, it can look at the source code. When it needs to see how the core team has implemented something, it can read the real code. When documentation is unclear, the source is the truth.

The skills are designed to work alongside the Umbraco repositories, guiding the AI to the right places and showing it how to learn from the source.

What About Testing?

As well as backoffice extension skills, there are also extension testing skills covering:

  • End-to-end testing with Playwright

  • Unit and component testing

  • Mock Service Worker (MSW) patterns for API mocking

These testing skills allow you to generate complete, production-ready test suites for your Umbraco extensions. More importantly, they are aligned with the same best practices, tooling, and base systems used by the core CMS team to test Umbraco itself.

By combining extension development skills with testing skills, agents can guide you from initial scaffolding all the way through to validated, production-ready code.

Getting Started

The full collection of Agent Skills is available on GitHub: https://github.com/umbraco/Umbraco-CMS-Backoffice-Skills

The repository includes information on how to use the Quickstart Skill, designed to help you build your first Umbraco extension with this set of Skills.

From there, you can explore the extension and testing Skills and start applying them directly within your Backoffice development process.

Watch the building of an entire new section in the backoffice using the Backoffice Extension Agent Skills, with end-to-end testing.

The Agent-Ready CMS - a 4-part series

This is the second post in our series. Catch up on the previous blog post and discover what topics await in April:

  1. Live: What are Agent Skills? - and why they matter for the future of your Umbraco project

  2. Live: Introducing Agent Skills: Umbraco Backoffice Extension (the blog post you’re reading now ;) )

  3. Coming up: Skills for Content Modeling and Implementation (ETA: mid-April)

  4. Coming up: Enable the Ecosystem: Our base MCP implementation for partners and package developers. (ETA: end-April)