AI-Powered Development for Cumulocity: Better Context, Better Reviews
Over the past few weeks I have been building two tools that I think make
Cumulocity development meaningfully better in the current AI era. This post walks
through what they are, why I built them, and how to get started.
Why AI tooling needs platform context
If you have used GitHub Copilot, Cursor, Claude Code, or anything similar, you
already know the productivity gains are real. Boilerplate disappears. Repetitive
work gets done faster. Starting a new feature no longer means staring at an empty
file.
But there is a catch that becomes obvious quickly when working on Cumulocity
specifically: these tools do not know our Web SDK. They know Angular. They know
component patterns in general. What they do not know is @c8y/ngx-components, the
right way to use DataGridModule, which CSS utility classes exist, how AlertService
is supposed to be injected, or how the dozens of built-in services and components
actually behave.
So you ask your AI assistant to build a view and get back code that compiles but
invents its own abstractions rather than using what is already there. You then spend
time correcting it, which eats into the gains. The assistant is not wrong, it just
does not have the context it needs.
This is the problem MCPs (Model Context
Protocol) are designed to solve. An MCP server sits between your editor and a
knowledge source, and lets your AI pull in relevant information on demand. Your
assistant asks “what does the Codex say about device registration?”, the MCP
fetches and returns the actual documentation, and suddenly the answer is grounded
in platform reality.
c8y-codex-mcp
c8y-codex-mcp is an MCP server that
mirrors the Cumulocity Codex and exposes it
through a set of tools your AI assistant can call during a conversation.
The Codex is the official documentation for the Cumulocity Web SDK. It covers
@c8y/ngx-components, Angular services, CSS utility classes, component APIs, and
everything else you need when building frontend applications on the platform.
The server is built on Cloudflare Workers and driven by the official
cumulocity.com/codex/llms.txt. It fetches and caches the Codex structure on
demand, resolves documents lazily, and falls back to browser-rendered content for
pages where the raw markdown is not enough. In practice this means your assistant
can search the Codex, pull full component docs, and reference specific APIs while
helping you write code, without you having to copy-paste anything manually.
There is a hosted instance you can use right now:
https://c8y-codex-mcp.schplitt.workers.dev/mcp
Connecting it to your editor is a one-liner or a small config file depending on
what you use.
VS Code (.vscode/mcp.json):
{
"servers": {
"c8y-codex-mcp": {
"type": "http",
"url": "https://c8y-codex-mcp.schplitt.workers.dev/mcp"
}
}
}
Claude Code:
claude mcp add --transport http c8y-codex-mcp https://c8y-codex-mcp.schplitt.workers.dev/mcp
Cursor and Windsurf work the same way, see the
website for the config snippets.
Once it is connected, your AI session has access to the full Codex. Ask it how
DataGridModule columns are configured, look up which CSS classes are available
for a particular layout, or ask it to find the right @c8y/ngx-components service
for what you are trying to do. It will pull the relevant docs and base its answer
on them.
The quality side of the equation
Faster output creates a second problem: reviews.
When you are shipping more code, PRs come faster, and review time per PR shrinks.
It is not that reviewers get worse, it is that the ratio of code to reviewer
attention tips. Things slip through. Feedback gets shallower. Over time this is how
quality drags.
The same instinct that led me to build the MCP applies here too: give the tools the context they
need to be useful. A reviewer (human or automated) that
understands the Cumulocity platform is way more useful than one that only knows
general best practices.
clank8y
clank8y (pronounced “klæŋki”) is a PR
review bot for Cumulocity projects. It is a GitHub App that runs as a GitHub
Actions workflow in your own repository, on your own infrastructure, using your
own model keys. Nothing is routed through a third-party service.
clank8y runs automatically when a PR is opened, and can also be triggered on demand
by mentioning it in a comment:
@clank8y please review this
Either way, a webhook dispatches the clank8y.yml workflow in your repo. The
workflow runs the agent, which reads the PR diff, pulls in relevant Codex
documentation via the MCP server, and submits a proper GitHub PR review with inline
comments on the relevant lines.
clank8y ships with two MCP servers wired in: c8y-codex-mcp for the Cumulocity
Web SDK docs, and the official Angular MCP for
Angular documentation, examples, and API references. So instead of generic
feedback like “this component API looks off”, it can tell you that you are using
@c8y/ngx-components in a way that does not match what the Codex documents, or
that an Angular pattern deviates from current framework recommendations. That
combination covers most of what a Cumulocity frontend PR actually needs reviewed.
You can also direct it. After pushing a fix:
@clank8y the subscription handling is updated, can you re-review and focus on the error paths?
The setup is minimal. Add a clank8y.yml workflow file to your repo’s default
branch, save a COPILOT_GITHUB_TOKEN (a fine-grained PAT with the Copilot Requests
account permission) as a repository secret, and install the GitHub App. That is it.
Full setup instructions including the workflow file are in the
repo.
What this looks like in practice
The combination is: you write code faster and with better platform context because
your editor’s AI knows the Codex. When you open a PR, clank8y catches the things
that slipped through anyway, also using the Codex. The human reviewer then looks at
a PR that has already been filtered for obvious issues and can focus on the parts
that actually need judgment.
Neither tool removes the human from the loop. The goal is to make the loop more
efficient and the feedback in it more useful.
If you are building on Cumulocity and already using AI tooling, both are worth
trying. Both are MIT licensed and open to contributions.