One engineering standard for every AI coding agent

Agents that ask before guessing, change only what you asked,
and tell you exactly what they did not verify.

Claude Code · OpenAI Codex · Cursor · GitHub Copilot · Gemini CLI

npx maisongr-skills

Why this exists

AI coding agents rarely fail for lack of knowledge. They fail because finishing the task pulls harder than doing it right. So they:

• guess what you meant instead of asking;
• build abstractions and options the task never needed;
• "improve" files nobody mentioned;
• report "all tests pass" without running them;
• push, drop a column or break a public API when nobody asked them to.

And when your team uses three different agents, you get three different standards, or none.

Maison GR gives every agent the same seven principles and ten task methods, from one source file, installed with one command.

60 seconds

1. In any project, run npx maisongr-skills.
2. Ask your agent for something slightly ambiguous: "Add caching to the users endpoint."
3. Instead of guessing, it asks what to cache and for how long, or states the assumptions it made.
4. When it finishes, it reports what it did and what it could not check. For example:

Changed:      src/api/users.ts: added a 60 s cache to GET /users
Verified:     npm test (42 passed), npm run lint (clean)
Not verified: cache invalidation under concurrent writes (no integration environment)
Decisions:    chose in-memory over Redis; revisit if you run more than one instance

Undo it any time with npx maisongr-skills remove.

Receipts: "tests pass" you can check

An agent can write "Verified: npm test (42 passed)" without having run anything. With the Claude Code plugin installed, Maison GR checks.

• Every shell command the agent runs in a session is recorded, with its exit code.
• When the agent tries to finish, each command listed under Verified is checked against that record.
• If a command never ran, or its last run failed while the report says it passed, the agent is sent back to run it and report the real result, or to move it to Not verified.

Maison GR receipts: your report lists commands under "Verified" that this session's record does not support:
- `npm test`: no command like this ran in this session.
Run them now and report the real result, or move them to "Not verified" with the reason.

The same record catches guarded actions taken silently (see principle 7, Guard irreversible actions). If the session force-pushed, skipped Git hooks with --no-verify, staged everything with git add -A, rewrote history (amend, rebase, reset --hard), or changed Git config, and the report never mentions it, the agent is sent back to own and justify the action — or undo it.

Maison GR receipts: this session took a guarded action without owning it in the report:
- this session force-pushed (`git push --force origin fix/foo`) but your report never mentions it.
Each is allowed only if the user asked for it here. Say so and justify it in your report, or undo it.

It checks only command names in backticks (and the guarded Git actions above), never blocks twice in a row, and keeps its record on your machine, in Claude Code's plugin data folder. Receipts need the Claude Code plugin; other agents get the same report format without the check.

How it works

flowchart LR
    N["npx maisongr-skills"] ==> A
    A["AGENTS.md<br/>7 principles, always on"] --> C[Claude Code]
    A --> X[Codex]
    A --> U[Cursor]
    A --> P[Copilot]
    A --> G[Gemini CLI]
    S["10 skills<br/>loaded on demand"] -.-> C & X & U & P & G

• Principles are short, always-on instructions in AGENTS.md, the file most agents already read. About 6 KB.
• Skills are detailed methods an agent loads only when a task matches, in the open Agent Skills format.
• Subagents (Claude Code and Gemini CLI) run review, design and testing in their own context.

The installer writes each piece where each agent natively looks for it. It adds the principles in a marked block above your existing AGENTS.md, updates only that block on later runs, and removes only what it added.

The principles

Every task follows the same loop:

flowchart LR
    I[Inspect] --> Q[Clarify] --> P[Plan] --> M[Implement] --> V[Verify] --> R[Report]
    Q -- ambiguous --> Ask((Ask you))
    V -- fails --> M

The reasoning behind each principle · Each one in a realistic scenario

The skills

Agents pick a skill up when a request matches it. "Users say the CSV import drops rows" loads maisongr-debugging: reproduce, find the root cause, fix, add a regression test. To call one directly: /maisongr:maisongr-security-review in Claude Code, $maisongr-security-review in Codex.

Install

Any agent, one command (Node.js 18.3 or later), from your project's root:

npx maisongr-skills                       # all five agents
npx maisongr-skills --agent codex,cursor  # only some: claude, codex, cursor, copilot, gemini
npx maisongr-skills --global              # your user account, every project
npx maisongr-skills --dry-run             # show what would change
npx maisongr-skills remove                # undo

Commit the result so your whole team, and every agent, works to the same standard.

Claude Code plugin, inside Claude Code:

/plugin marketplace add maison-gr/maisongr-ai-engineering-skills
/plugin install maisongr@maison-gr

Gemini CLI extension:

gemini extensions install https://github.com/maison-gr/maisongr-ai-engineering-skills

The plugin and extension install the skills and subagents; for the always-on principles in Claude Code, also run npx maisongr-skills --agent claude or add @AGENTS.md to your CLAUDE.md. The installation guide covers project and user scopes, manual copying, updates and removal on every platform.

Make it yours

• Add your project's specifics. Put your commands, conventions and boundaries below the Maison GR block in AGENTS.md, starting from templates/project-instructions.md. Specific instructions take precedence over the general principles.
• Plan bigger changes. Ask the agent to fill in templates/implementation-plan.md and wait for your approval.
• Pick your skills. Each skill folder is self-contained; keep only the ones your team needs.

Agent still got it wrong?

If an agent with Maison GR installed still guessed, over-built, touched files it should not have, or claimed checks it never ran, send us the transcript. Each report becomes a test case for the next release.

To contribute a fix, a skill or a new platform, read CONTRIBUTING. How the repository is built: architecture.

Credits

Maison GR started from andrej-karpathy-skills and its four principles for LLM coding agents. It adds principles for verification, security and irreversible actions, ten task skills, subagents, one generated source for five platforms, and an installer. RESEARCH.md lists every project and document that informed the design.

Further reading

Principles · Examples · Installation · Compatibility · FAQ · Architecture · Changelog

License

MIT © Maison GR