CodeHealth MCP Server by CodeScene - Keep AI-generated code healthy and maintainable

@adam_tornhill_cs Really resonates. MCP flips this from insight → action.

Instead of just knowing where technical debt is, teams can now operationalize it in real-time workflows, prioritizing hotspots, guiding AI agents, and preventing bad code from scaling.

AI doesn’t just need code. It needs context. That’s where MCP becomes a force multiplier.

@adam_tornhill_cs instructing an agent is hard enough trying to do it in a messy codebase is impossible. CodeHealth MCP feels like 'cleaning up the room' before you ask a guest to come over. Makes the agent way more effective. Congrats on the ship!

@conduit_design It's CodeScene analysis tools as an MCP, which works in the same space as SonarQube. It can help you do code health reviews, uplifting of unhealthy code and safeguarding AI generated code. Is there a specific use case you're interested in?

@conduit_design Thanks and lot, André!

CodeScene's MCP is based on the Code Health metric. It's the only validated code-level metric with a proven impact in terms of faster (shorter lead times) and better (fewer defects).

Compared to linting aggregators like SonarQube, Code Health works at a higher level. Think of linters like the line-by-line commenting whereas Code Health checks the design and structure of the code to guide agents.

Does that help explaining the difference?

@avrisimon You can instruct AI to self-correct by having instructions in your generic `AGENTS.md` or `CLAUDE.md` file (depending on agent), which the agent will read as sort of a global context. We have an example `AGENTS.md` file in our repository here if you want to take a look: https://github.com/codescene-oss/codescene-mcp-server/blob/main/AGENTS.md.

The number of iterations it needs to do to achieve healthy code depends on a few factors, so it's hard to give a concrete number. How bad is the code? The worse the code is, the harder it will be for AI to one-shot the solution. How good is the AI model you use? The better the model, the better it can understand instructions given by the CodeHealth MCP. In general though, with the latest Opus models from Claude and with code health even as low as 2 out of 10, I've personally seen it able to get to 10 out of 10 in just 2 iterations.

The MCP is also great at safeguarding already healthy code so that AI can't start introducing subtle defects or code smells into your code. This is important because healthy code requires a lot less tokens to understand and you need to spend no tokens at all on refactoring, saving you money.

Does that answer your question?

@avrisimon Great point, and that scaling experience really puts the problem in perspective

@lht8 "Works but nobody should touch this", we've all shipped that code🙈, and it's even easier to do when the AI is moving fast for you. Really glad the health scoring gives you something concrete to aim at rather than just vibes-based cleanup. Thanks for being a CodeScene user and for jumping on this so quickly 🙌

@lht8 Thanks for that lovely feedback, Marcus. Supper happy to hear that!

having real-time CodeHealth feedback baked directly into my AI coding assistant is a game changer. It catches the kind of subtle technical debt that accumulates fast when you're moving quickly

This is so important. An AI won't write "good enough" code on its own. In fact, we find that agents often operate in a kind of self-harm mode. They generate code that is inherently incompatible with, well, themselves. (A strange paradox).

With the CodeHealth MCP, we safeguard all code. It's the tool that enabled me and my team to go fully agentic. And we're not looking back 😊

Thanks@lht8 , much appreciated!

@ben_gend Yes, those are first class citizens in the Code Health score. Functions doing too many things are caught as Brain Methods, a dedicated metric for complex functions that centralize too much behavior. Classes that have grown beyond reasonable scope show up as Brain Classes (large modules with too many responsibilities) or Low Cohesion, which specifically measures whether a class has multiple unrelated responsibilities breaking the Single Responsibility Principle.
There's also Bumpy Road, which catches functions with multiple dispersed chunks of logic that should have been extracted into their own functions.

You can read more about our Code health metric here: https://codescene.io/docs/guides/technical/code-health.html#code-health-identifies-factors-known-to-impact-maintenance-costs-and-delivery-risks

@ben_gend Yeah, "did I just create six months of tech debt in 20 minutes" is really worrying as many developers don't even think about this impact. The see the larger commits but their current task was solved...

Thanks for your question@ben_gend CodeScene looks at some 25 different roles that drives complexity. You can read more about some of the smells here (https://docs.enterprise.codescene.io/latest/guides/technical/code-health.html#module-smells)

@johan_nordberg Thanks a lot for your feedback!

I also use the MCP server to ask about code that I might think is too complex, or where I sense something is wrong, but can't really put words on it. The MCP is so good at evaluating the code quality and give suggestions for improvements.

I like that. It's a really important aspect of going agentic. Our research finds that AI requires even better code quality than humans, not less. The CodeHealth MCP allows us to pull that risk forward, and strategically refactor code to make it AI-ready.

@johan_nordberg Couldn't agree more on the amplification effect, it's probably the most underrated risk in AI-assisted development right now.

@tajib_smajlovic Thank you so much for your support, our team appreciates it a lot. How reliable has AI-generated code been for you in production so far?

@tajib_smajlovic I'm glad you like the product!

@tajib_smajlovic Great to hear Tajib! Looking forward to hearing your thoughts on the MCP 🙏

@tajib_smajlovic Thanks for the feedback Tajib!

Thank you@tajib_smajlovic !

@tadej_kosovel Deterministic is the only way in the world of non-deterministic AI, I think.

The scoring model looks at many things; module smells, function smells and implementation smells. Part of those are things such as cyclomatic complexity and coupling indeed, but there's a whole lot more that goes on, and we keep continuously improving that metric as we go along. You can read more specific info on the CodeHealth metric here: https://codescene.io/docs/guides/technical/code-health.html#code-health-identifies-factors-known-to-impact-maintenance-costs-and-delivery-risks.

Does that help answer your question?

@tadej_kosovel Agree 100%. We really believe on deterministic quality signals is key for the current LLMs.

@odeth_negapatan1 Thank you, Odeth!

It's important to have checks that verify AI created code. You could have unit tests in place and instruct AI to make sure that tests pass. You could instruct AI to always check that test coverage is a high percentage (at CodeScene we try to aim for 95%+), this way AI can deterministically check if tests cover the logic it created or not. Finally you could have our CodeHealth MCP which can check for code quality issues, degradations, do uplifting and safeguarding.

Does this help answer your question?

Thanks odeth_negapatan1 you should try it out!

@odeth_negapatan1 

Thank you Odeth, really appreciate your kind words and looking forward to hearing your thoughts when you have tried it out :)

@johan_martinssonInteresting point about micromanaging, it actually help you with that.

@johan_martinsson1 Thank you! We think the CodeHealth MCP is the missing link in agentic programming. You should definitely give it a go!

@johan_martinsson1 Not having to micromanage quality is exactly the goal, agents should self-correct, not wait for a human to notice the mess