Code Quality Skill: Stop Your Agent from Shipping Broken Code

Where this fits

You've just asked your dev agent to add a new API endpoint. It writes the code, runs tests, and reports success. But later, you discover it silently swallowed a network error and returned a default value. That's a fail-open branch — the agent optimized for convenience over correctness. The code-quality skill exists to prevent exactly this. It loads before any code-writing task and injects a set of hard rules: no workarounds, no silent fallbacks, prove your guards. If your agent is generating code beyond trivial snippets, this skill keeps it honest.

Why agents benefit

• Eliminates fail-open branches: The skill explicitly forbids continuing in an unknown state. Agents must handle every error path or loudly abort.
• Forces proof over assumption: Guards and invariants must be demonstrated, not just declared. The agent has to reason about why a check is sufficient.
• Reduces over-engineering: Limits on complexity mean the agent doesn't build speculative abstractions — it solves the actual problem.
• Improves comment discipline: Comments explain why not what, reducing noise and making the codebase easier to maintain.
• Creates a consistent baseline: Every agent run follows the same authoring standards, regardless of the underlying model or prompt drift.

Practical scenarios

Adding a new dependency call

Your agent needs to call an external service. Without the skill, it might wrap the call in a try/catch and return a cached value on failure. With code-quality, it must decide: either the failure is fatal (abort loudly) or it's handled with a clear, documented fallback that doesn't hide the error.

Refactoring a legacy function

During refactoring, the agent might be tempted to leave a known bug because the fix would require changing the function signature. The skill's "no workarounds" rule forces it to either implement the correct fix or explicitly flag the issue instead of shipping a shortcut.

Writing a file parser

Parsing untrusted input is a classic place for silent failures. The skill's "prove-your-guards" rule makes the agent validate every assumption about the input format, and if a guard fails, it must raise an error rather than skip the malformed record.

Add it to your agent workflow

Install the skill with:

npx skills add vanillagreencom/kendex --skill code-quality

Then load it before any code generation or modification task. For example, in your agent's system prompt or task preamble:

Load the code-quality skill before writing or editing code. Apply all rules strictly.

The skill is designed to be additive — it doesn't override repo-specific instructions but layers on top of them. For more context, see the skill page on OpenAgentSkill.

Compare before adopting

Before you commit, evaluate the skill against your own quality signals: Does it catch the failure modes you care about? Check maintenance freshness — the repo is actively updated and has a clear issue tracker. Compare with alternatives like repo-specific linting rules or custom prompt templates. The skill is generic by design, so it should complement your existing guardrails, not replace them.

Why it is worth tracking

With 63 stars and a clear, focused scope, this skill is gaining traction in the agent-engineering community. Its core principle — "a loud failure beats a silent wrong answer" — is a widely accepted best practice, and the skill operationalizes it. If you're building agents that write production code, this is worth evaluating now and monitoring as the ecosystem evolves.