Getting Started with Claude Code for Kentico Development
Most Kentico developers don’t struggle because the platform is hard. They struggle because the work is cognitively expensive. You’re constantly context-switching between CMS abstractions, content models, APIs, Razor views, business rules, and client-specific edge cases. The real bottleneck isn’t syntax or tooling. It’s attention.
This is where AI—used correctly—becomes transformative.
Claude Code isn’t interesting because it can “write code.” It’s interesting because it absorbs low-leverage thinking: scaffolding, repetition, pattern recall, and translation between mental models. When used with intent, it turns Kentico development from a series of cognitive interrupts into a sustained flow.
This post is not about replacing developers or blindly trusting AI output. It’s about using Claude Code as a force multiplier so your limited human judgment stays focused on architecture, trade-offs, and correctness.
⸻
What Changes When You Introduce Claude Code
Before Claude, a typical Kentico task looks like this: you mentally reconstruct the project’s structure, recall how a specific Xperience API behaves, search documentation or past code, write boilerplate, adjust it to the project’s conventions, then finally solve the actual problem you were hired to solve.
After Claude, that sequence compresses.
Claude can generate initial scaffolding for page models, view models, Razor patterns, repository layers, and even Kentico-specific conventions when you provide it with grounding context. It can refactor existing code to align with newer Xperience patterns. It can explain unfamiliar sections of a legacy project faster than any human onboarding process. Most importantly, it does this while keeping you in the same cognitive lane instead of forcing you to context-switch.
What does not change is responsibility. You still validate assumptions. You still make architectural calls. You still own correctness. Claude accelerates execution; it does not absolve judgment.
⸻
How to Use Claude Code Effectively in a Kentico Workflow
Claude performs best when it is treated as a collaborator with memory constraints, not as an omniscient assistant.
You will get the most value when you feed it concrete artifacts: existing code files, content type definitions, Razor views, and clear descriptions of constraints. The more explicit you are about the Kentico version, project structure, and architectural rules, the less likely it is to hallucinate APIs or patterns that don’t exist.
In practice, Claude excels at things like:
• Generating first-pass implementations that follow Kentico conventions
• Translating Portal Engine or older patterns into Xperience by Kentico equivalents
• Refactoring repetitive code safely
• Acting as a second brain when reasoning through unfamiliar or inherited codebases
Used this way, it reduces time spent on mechanical thinking and increases time spent on high-value decisions.
⸻
The Real Constraint: Context Windows and How to Survive Them
Claude’s biggest limitation in real-world development work is not accuracy. It’s context.
Long-running Kentico tasks routinely exceed context windows. Conversations get compacted. Sometimes you hit the wall entirely and have to start over. If you pretend this isn’t a problem, your workflow will break.
The solution is not frustration. It’s process.
I handle this in two complementary ways.
First, I maintain lightweight but regular documentation that captures the current state of the project, architectural decisions, known constraints, and immediate to-dos. This is not documentation for humans six months from now. It’s documentation for re-hydrating context—both mine and the AI’s—quickly and accurately.
Second, when a conversation reaches a critical mass of understanding, I have the AI dump the full working context into a temporary file. This file is written explicitly so another AI agent can ingest it and continue work without ambiguity. It includes what we are building, what has already been decided, what must not change, and what remains unresolved.
When context is lost, I don’t re-explain from memory. I re-seed the agent with artifacts. This turns context limits from a blocker into a manageable boundary.
This discipline is the difference between AI being a novelty and AI being infrastructure.
⸻
What Claude Is Bad At (and Why That’s Fine)
Claude is bad at guessing. It will confidently invent APIs if you let it. It will generalize when precision is required. It will misunderstand project-specific conventions unless you show them explicitly.
This is not a flaw. It’s a reminder that AI is a statistical engine, not a source of truth.
When you treat Claude as a junior developer with infinite energy but zero domain memory, its behavior makes sense. You give it constraints. You review its output. You correct it. Over time, your prompts get sharper, and its usefulness compounds.
⸻
The Strategic Reality for Agencies
By 2026, agencies will not compete on raw headcount. They will compete on throughput per developer.
One developer with a disciplined AI workflow will outperform teams that treat AI as autocomplete or novelty. The advantage compounds quietly: faster onboarding, less burnout, more consistent output, and higher margins without sacrificing quality.
Claude Code is not the strategy. It is the leverage. The strategy is learning how to think, document, and build in a way that assumes AI is part of the system.
That shift is already underway.
About this post: This guide is based on real-world Xperience by Kentico 31.x development workflows. The patterns and examples reflect production implementations, not theoretical scenarios.