Coding Codex — The AI Programming Rulebook

Coding Codex is a rule-based skill library for AI-assisted programming (VibeCoding). Through 20 standardized, AI-parsable development rules, it constrains AI to generate high-quality code — boosting efficiency, accelerating delivery, improving quality, saving tokens, and preventing endless refactoring.

🇨🇳 切换至中文版

Why Coding Codex

The Problem

In AI-assisted programming, unconstrained AI tends to generate:

• Inconsistent code — mixed naming conventions and architecture patterns within the same project
• Low-performance code — N+1 queries, memory leaks, infinite scroll freezes
• Insecure code — unauthorized access, sensitive data exposure, SQL injection
• Ultimately leading to endless refactoring, wasting significant time and tokens

The Solution

Coding Codex abstracts enterprise-grade development standards into 20 granular, composable Skills, covering the full development lifecycle from workflow to DevOps, constraining AI behavior at the source.

Use Cases

• Building new projects from scratch — AI follows best practices from the very first line of code
• Modifying existing projects — Rules prevent AI from breaking established architecture
• Rapid prototyping — Maintain code quality while pursuing speed

Core Features

• 20 independent, composable skill modules — Fine-grained decomposition prevents LLM "forgetting" in long contexts
• Concrete rules + anti-patterns + correct examples — Each skill contains <rules> (mandatory constraints), <anti-pattern> (what NOT to do), and <examples> (recommended practices)
• Standardized format — YAML Frontmatter + Markdown + XML Tags, natively parsable by AI
• Native bilingual support — skills/en/ and skills/zh-CN/ are fully symmetric
• Compatible with mainstream AI coding tools — Claude Code, Qoder, Cursor, etc.

Skill Rules List

All skills are located in the skills/ directory with two language versions: skills/en/ and skills/zh-CN/.

Workflow (01–03)

#	Skill	Description
01	workflow-progressive	Progressive development and plan-first workflow rules
02	workflow-destructive	Warning triggers for destructive or high-risk operations
03	workflow-large-files	Restrictions on modifying large files to prevent context loss

Frontend (04–06)

#	Skill	Description
04	frontend-ui-state	Frontend UI consistency, styling, and state management rules
05	frontend-performance	Frontend performance baselines and limits
06	frontend-resilience	Frontend network resilience and graceful degradation

Backend (07–10)

#	Skill	Description
07	backend-layer-arch	Strict separation of concerns for backend layers (Controller/Service/Repo)
08	backend-domain-models	Rules for DTO, DO, and VO separation
09	backend-clean-code	Cyclomatic complexity and code cleanliness limits
10	backend-exceptions	Global exception handling and preventing silent failures

API (11–12)

#	Skill	Description
11	api-standards	API design and response format standards
12	api-third-party	Rules for integrating external third-party HTTP services

Security & Robustness (13–16)

#	Skill	Description
13	security-rbac	RBAC, authorization, and data sanitization rules
14	robustness-idempotency	Idempotency design for state-mutating operations
15	robustness-validation	Defensive programming and input schema validation
16	robustness-resources	Resource cleanup and preventing memory leaks

Database (17–18)

#	Skill	Description
17	database-schema	Database table design and audit field constraints
18	database-performance	Auditing queries to prevent N+1 performance issues

Cross-cutting (19–20)

#	Skill	Description
19	i18n-standards	Internationalization (i18n) standards for frontend and backend
20	devops-infra	DevOps, Containerization, Nginx, and Object Storage rules

Quick Start

# 1. Clone the repository
git clone https://github.com/haojichong/coding-codex.git

# 2. Browse the skill rules (choose en or zh-CN)
ls coding-codex/skills/en/

# 3. Copy the skills directory into your project for use with AI coding tools
cp -r coding-codex/skills/ your-project/skills/

💡 After copying, refer to the "Import & Usage Guide" below to configure your AI tool.

Import & Usage Guide

① Claude Code

Configure rules via CLAUDE.md and .claude/settings.local.json.

Option 1 (Recommended): Include the skills directory in your project and reference rules in CLAUDE.md

Copy the skills/ directory into your project, then add the following to CLAUDE.md in your project root:

## Development Rules

Before writing code, read and strictly follow the rules in the `skills/en/` directory.

- Workflow rules (always active): `01-workflow-progressive.md`, `02-workflow-destructive.md`, `03-workflow-large-files.md`
- Apply domain-specific rules (frontend/backend/API/security/database, etc.) based on the file types you are editing.

Option 2: Instruct AI to read rules at the start of a conversation

Before writing code, please read and strictly adhere to the rules defined in the skills/en/ directory.
Apply rules based on the file types you are working with.

---

② Qoder

Configure rules via the .qoder/rules/ directory or the Settings UI.

Option 1 (Recommended): Copy to .qoder/rules/ directory

cp skills/en/*.md your-project/.qoder/rules/

Qoder will automatically detect and activate rules based on the globs field.

Option 2: Add rules via the Settings UI

Open Settings (Ctrl+Shift+, on Windows / Cmd+Shift+, on macOS) → Rules → Add, and choose the rule type as follows:

Skill Type	Rule Type	Notes
Workflow (globs: "*")	Always Apply	Always active
Domain-specific (e.g., globs: "*.{py,java,go}")	Specific Files	Paste the corresponding globs value
On-demand	Model Decision	Use the skill's description as scenario context

---

③ Cursor

Configure rules via the .cursor/rules/ directory.

Option 1 (Recommended): Copy to .cursor/rules/ directory and rename to .mdc

cp skills/en/*.md your-project/.cursor/rules/
cd your-project/.cursor/rules/
for f in *.md; do mv "$f" "${f%.md}.mdc"; done

Cursor will automatically activate rules based on the globs field when matching files are edited.

Option 2: Merge global rules into .cursorrules file

For rules that should always be active (like workflow rules with globs: "*"), merge them into your project's .cursorrules file:

cat skills/en/01-workflow-progressive.md >> your-project/.cursorrules

Verify Rules Are Active

After importing rules, verify that AI has correctly loaded them:

Claude Code

In the conversation, type:

"List the development rules you are currently following"

Confirm the AI recognizes the rules referenced in CLAUDE.md.

Qoder

Open Settings (Ctrl+Shift+, on Windows / Cmd+Shift+, on macOS) → Rules, and confirm the imported skills appear in the rules list. Or ask in conversation:

"List the development rules currently in effect"

Cursor

Open a file matching the globs pattern (e.g., a .java file), then ask in Chat:

"What development rules are currently active?"

Confirm the AI can list the corresponding rule names and constraints.

Generic Verification

Ask the AI to write code that intentionally violates a rule, for example:

"Write a SQL query directly in the Controller"

If rules are active, the AI should refuse or warn that this violates the layered architecture rule (Skill 07).

Skill File Format

Each skill file follows this standard structure:

---
description: "Short description of the skill's purpose"
globs: "*.{file,extensions}"
---

Tag	Purpose	Required
<context>	Describes when this skill applies	Yes
<rules>	Specific mandatory rule entries	Yes
<anti-pattern>	Counter-examples: what NOT to do	No
<examples>	Correct examples: recommended practices	No

Customization

• Language: Use skills/zh-CN/ for Chinese projects, skills/en/ for English.
• Selectivity: You don't need all 20 skills — pick only the ones relevant to your project's tech stack.
• Modification: Each skill is self-contained. Edit individual rules without affecting others.

License

Apache 2.0

---

Driven by AI, Ruled for AI.