- [Home page](https://www.brimit.com/)
- [Blog](https://www.brimit.com/blog)

# Extending Claude Code for Sitecore XP Development

[Tech Talks](https://www.brimit.com/blog?categories=Tech%20Talks) [Sitecore](https://www.brimit.com/blog?platforms=Sitecore)
[Igor Zharikov](https://www.brimit.com/blog/author?authors=Igor%20Zharikov) on September 14, 2026

![Claude Code + Sitecore XP](https://www.brimit.com/-/jssmedia/images/blog/sitecore-xp-claude-setup/logo.png?h=720&iar=0&w=1280&hash=A5D7F4FAB554A1A09C08BC8540245FD4)

In this article, I explain how I extended Claude Code to work better with Sitecore XP.

### TL;DR

The full setup (skills, scripts and hooks) - is in
[izharikov/sitecore-xp-skills](https://github.com/izharikov/sitecore-xp-skills).

## Sitecore XP development with Claude

On its own, [Claude Code](https://code.claude.com/docs/en/features-overview) already handles the codebase. But in comparison to a popular any open-source stack

>
>
> Coding Agent has some limitations working with Sitecore XP:
>

- closed platform - no public source; behaviour is compiled into shipped assemblies
- limited public material - sparse docs and examples next to a stack like Next.js
- state lives in a database - content, templates and renderings reach Git only through serialization
- variety of configs - Sitecore ships with thousands of configuration files and settings, hard to locate without knowing where to look

## Setup

### CLAUDE.md

[Claude Memory](https://code.claude.com/docs/en/memory) starts with the *CLAUDE.md* file. Keep it short, but enough for Claude Code to understand your project.

For a project CLAUDE.md I usually include this Sitecore-related information:

- Sitecore version and projects architecture (e.g. 10.4.1 and Helix)
- Serialization: Unicorn, Sitecore Content Serialization (SCS), TDS, etc.
- Code Generation tool: Leprechaun, T4-Templates, etc.
- Build Process: e.g. build script which Agent can run to verify work (or an explicit rule against running the build)
- Unit Tests policies
- General code rules important for each and every (or most) Claude Code sessions

### Templates and renderings

I choose the following rule:

>
>
> Every tool works on local files under version-control.
>

The alternative to a local skill is an MCP server wired to a live instance, like
the [Sitecore Community MCP server](https://github.com/Antonytm/mcp-sitecore-server).

#### Skill vs MCP for Items Editing

|  | Skill | MCP |
| --- | --- | --- |
| Changes land in | source files under Git | the live instance |
| Review | diff in a pull request | none |
| Revert | like any other commit | manual fix |
| Sitecore running | not needed | required |
| Feedback loop | build and sync first | immediate |

#### Templates

Template creation is usually a **manual process** done in the Content Editor: here a developer adds the template, its
sections, then every field, one by one.

![Manual template creation](https://www.brimit.com/-/media/images/blog/sitecore-xp-claude-setup/template-manual.png)

After that, Sitecore serializes it to files on disk, so it
can be shared and deployed. For Claude Code I change the direction:

>
>
> [`/sc-template`](https://github.com/izharikov/sitecore-xp-skills/blob/main/skills/sc-template/SKILL.md) skill:
>
>
> Edit the YAML locally and sync it back into
> Sitecore, so a template change is a file change.
>

```
before (manual):  [developer]  Sitecore   -> serialize -> repository
now (automated):  [agent]      repository -> sync      -> Sitecore
```

To simplify the process and save tokens, it's wrapped into a PowerShell script call:

```
powershell -File .\.claude\skills\sc-template\Invoke-TemplateOp.ps1 -Json '{
  "operation": "create", "layer": "Feature", "module": "<ModuleName>",
  "templateName": "Article Page", "sectionName": "Data",
  "fields": [
    { "name": "Title", "type": "Single-Line Text" },
    { "name": "Body", "type": "Multi-Line Text" },
    { "name": "Summary", "type": "Multi-Line Text" }
  ]
}'
```

And skill is calling it:

![Create template with Claude Code](https://www.brimit.com/-/media/images/blog/sitecore-xp-claude-setup/cc-template-create.png)

*Note*: Unicorn and SCS both work here - only the file format changes.

#### Renderings

Creating a rendering touches even more places than a template. By hand the routine is:

- add the rendering item
- point it at a datasource template
- register it on the placeholders it is allowed in
- write the controller action
- write the Razor view

**Five manual edits** across the Content Editor and the codebase, and they all have to line up.

For Coding Agent I choose a similar approach to templates:

>
>
> [`/sc-rendering`](https://github.com/izharikov/sitecore-xp-skills/blob/main/skills/sc-rendering/SKILL.md) skill:
>
>
> To create rendering do all the steps locally (file edits) then deploy code and sync Unicorn to have the Sitecore rendering ready.
>

```
powershell -File .claude/skills/sc-rendering/New-Rendering.ps1 -Module Accordion `
  -RenderingName "Accordion Container" `
  -ControllerClass AccordionController -ActionName Container `
  -DatasourceTemplatePath "/sitecore/templates/Feature/Accordion/Accordion Container" `
  -DatasourceModelInterface IAccordionContainer
```

![Create rendering with Claude Code](https://www.brimit.com/-/media/images/blog/sitecore-xp-claude-setup/cc-rendering-create.png)

#### Content Editing

Content editing itself I do not automate yet. The same serialization approach applies (edit yaml file locally for page/datasource and sync), or
an MCP server against a running instance, like the
[Sitecore Community MCP server](https://github.com/Antonytm/mcp-sitecore-server).

### SPE scripting with an LLM

[Sitecore PowerShell Extensions (SPE)](https://doc.sitecorepowershell.com/) is a popular addition to the platform, used widely. And of course Coding Agent can generate SPE scripts.

While in most cases it works, sometimes Agent hallucinates: SPE is very similar to PowerShell, so LLM starts 'guessing' names and parameters. The
cmdlets read like ordinary PowerShell but are a separate set, so it writes a plausible name or
parameter that does not exist. There is no compile step - the script fails only when it runs in a Sitecore instance.

>
>
> [`/spe`](https://github.com/izharikov/sitecore-xp-skills/blob/main/skills/spe/SKILL.md) skill:
>
>
> Verify PowerShell commands and parameters against existing documentation.
>

SPE documentation is comprehensive and easily machine-accessible in markdown format:

```
https://doc.sitecorepowershell.com/appendix/<category>/<lowercase-command>.md
```

| Without Skill | With Skill |
| --- | --- |
| ⚠️ Issues | ✅ Works |
| - Full name is not set
            - To set profile properties `-Authenticated` is required | - Full name is set
            - Uses `-Authenticated` |
| `powershell
            # --- Create user ---
            New-User -Identity $username -Enabled $true `
            -Password $password -Email $email
            # --- Set profile properties ---
            $user = Get-User -Identity $username
            $user.Profile.FullName       = $fullName
            $user.Profile.ClientLanguage = $clientLanguage
            $user.Profile.Save()` | `powershell
            $user = New-User -Identity $domainQualifiedName -Enabled `
            -Password $password -Email $email -FullName $fullName
            $user = Get-User -Identity $domainQualifiedName -Authenticated
            $user.Profile.ClientLanguage = $clientLanguage
            $user.Profile.Save()` |

### Sitecore XP Platform

Not every Sitecore internal is searchable in the docs. Some answers - which processors a pipeline
runs, what a setting defaults to - live only in the shipped configuration, and none of that is on
the public web.

Checking it usually means visiting `/sitecore/admin/showconfig.aspx` and searching for the required pipeline/config (but often it's unclear what to search for). But if unzip Sitecore installation locally and give access to Claude Code - it can grep it for us.

>
>
> [`/sitecore-platform`](https://github.com/izharikov/sitecore-xp-skills/blob/main/skills/sitecore-platform/SKILL.md) skill:
>
>
> Access to a Sitecore installation: browse all configs, XMLs, DLLs as its source code.
>

*Example*. Validate if it's possible to find page items (with presentation) from search index.

![Validate Sitecore question based on platform configuration](https://www.brimit.com/-/media/images/blog/sitecore-xp-claude-setup/sitecore-platform-skill-use.png)

### DLL decompilation

A developer who wants to know how a library really works decompiles it - Rider does it on a click,
Visual Studio with ReSharper too.

[ILSpy](https://github.com/icsharpcode/ILSpy) is the open-source decompiler behind that idea. It
ships a command-line tool, `ilspycmd`, that turns a compiled assembly back into C# and prints it -
no GUI, no project loaded:

```
dotnet tool install -g ilspycmd
ilspycmd path/to/Library.dll
```

I wrapped that in a skill: Claude runs it against an assembly and reads the source.

>
>
> [`/ilspy-decompile`](https://github.com/izharikov/sitecore-xp-skills/blob/main/skills/ilspy-decompile/SKILL.md) skill:
>
>
> Understand internals of the system by decompiling DLLs.
>

*Note*: check the license of the assembly before you decompile it. Terms differ per vendor, and
for a commercial product they usually restrict reverse engineering.

### Hooks

*CLAUDE.md* and every loaded skill add to the context on every request. Consider wrapping anything deterministic into hooks.

| Extension | What for |
| --- | --- |
| CLAUDE.md | a judgement the model makes every session |
| Skill | a multi-step operation, loaded only when needed |
| Hook | anything a machine can check or fix |

[Formatting](https://github.com/izharikov/sitecore-xp-skills/blob/main/hooks/Format-CSharpFile.ps1) is the clearest case. The rules are already in `.editorconfig`; a hook reapplies them
after each write - no added context, and it can't be skipped.

## Conclusion

>
>
> Claude Code already works with the Sitecore XP codebase.
>
>
> With skills it's more predictable and has better Sitecore context.
>

Templates, renderings, and Sitecore internals follow the same shape:

- templates and renderings go through a skill
- SPE cmdlets get checked live against the documentation
- agent has access to Sitecore internals

If you have built something similar for your Sitecore solution, or found a better shape for any of
these skills, let me know ([email](mailto:zharikovigor97@gmail.com) me or find me in Sitecore Slack).

###### More From Author

##### Sitecore 10.5 Release
August 7, 2026[Sitecore 10.5 Release](https://www.brimit.com/blog/sitecore-10-5-whats-new)

##### Sitecore Marketplace SDK Integration with Vercel AI SDK
February 25, 2026[Sitecore Marketplace SDK Integration with Vercel AI SDK](https://www.brimit.com/blog/sitecore-marketplace-sdl-integration-with-vercel-ai-sdk)

##### Sitecore Marketplace Updates (December 2025)
December 16, 2025[Sitecore Marketplace Updates (December 2025)](https://www.brimit.com/blog/sitecoreai-marketplace-december-updates)

###### Author

![Igor Zharikov - Senior Sitecore Developer, Sitecore MVP](https://www.brimit.com/-/jssmedia/feature/blogs/authors/igor-zharikov-2.jpg?h=700&iar=0&w=700&hash=292A84E8CB3E5CE57CA743385CFB1464)

Igor Zharikov

Sitecore MVP / Senior Sitecore Developer
[Igor Zharikov](https://www.brimit.com/blog/author?authors=Igor%20Zharikov)

###### More By Categories

[#Events](https://www.brimit.com/blog?categories=#Events) [#How-to](https://www.brimit.com/blog?categories=#How-to) [#News](https://www.brimit.com/blog?categories=#News) [#Guides](https://www.brimit.com/blog?categories=#Guides)

###### More by Platform

[Data and AI](https://www.brimit.com/blog?platforms=Data%20and%20AI) [DXP](https://www.brimit.com/blog?platforms=DXP) [E-commerce](https://www.brimit.com/blog?platforms=E-commerce) [Internet of Things](https://www.brimit.com/blog?platforms=Internet%20of%20Things) [Sales and marketing automation](https://www.brimit.com/blog?platforms=Sales%20and%20marketing%20automation)

#### More on Sitecore

![How Vercel Will Help You Save Effort When Deploying Sophisticated Sitecore Projects](https://www.brimit.com/-/jssmedia/project/brimit/blog/2024/vercel_cover-image.png)
#Guides #How-to DXP E-commerce

##### How Vercel Will Help You Save Effort When Deploying Sophisticated Sitecore Projects

Optimize and accelerate the development and deployment of complex multisite Sitecore projects.

Alexei Vershalovich on July 17, 2024
[How Vercel Will Help You Save Effort When Deploying Sophisticated Sitecore Projects](https://www.brimit.com/blog/how-vercel-will-help-you-save-effort-when-deploying-sophisticated-sitecore-projects)

![Training Up Tomorrow's Sitecore MVPs: a Mentoring Success Story](https://www.brimit.com/-/jssmedia/project/brimit/blog/2023/sitecore-mentoring---cover-image.png)
#How-to DXP

##### Training Up Tomorrow's Sitecore MVPs: a Mentoring Success Story

How to participate in the Sitecore Mentor program and help younger colleagues jump-start a career in Sitecore development.

Sergey Baranov on October 2, 2023
[Training Up Tomorrow's Sitecore MVPs: a Mentoring Success Story](https://www.brimit.com/blog/training-up-tomorrows-sitecore-mvps)

![Going Headless. Part 2: When a Headless CMS Is Your Best Bet (if you have Sitecore)](https://www.brimit.com/-/jssmedia/project/brimit/blog/2022/headless/adobestock_456986731.jpg)
#How-to DXP E-commerce

##### Going Headless. Part 2: When a Headless CMS Is Your Best Bet (if you have Sitecore)

Discover how a headless CMS can benefit organizations that use Sitecore.

Daniil Raschupkin, Palina Trokhautsava on September 15, 2022
[Going Headless. Part 2: When a Headless CMS Is Your Best Bet (if you have Sitecore)](https://www.brimit.com/blog/going-headless-part-2-when-a-headless-cms-is-your-best-bet-if-you-have-sitecore)