Claude md architect

Skill aimasteracc/harness-kit/skills/claude-md-architect

Five executable Claude Code skills for building autonomous agent harnesses that don't silently fail — failure-mode auditing, constraint-first CLAUDE.md, sub-agent briefing, context handoff, pre-flight checks.

Install

npx -y skills add aimasteracc/harness-kit --skill claude-md-architect

Assembled from the repository path, not quoted from the project. Check it against their README if it does not work.

2 things to look at

no licenseNo license file was found in the repository. Code published without one is not open source by default, so using it at work is a question for whoever answers licensing questions where you are.
0 stars0 stars. Stars are a popularity signal and not a quality one, but at this level it is likely that nobody has read this closely except its author, and you would be relying on your own review.

What its author says it does

Copied from the file, not written here

Generate a constraint-first CLAUDE.md (agent operating-rules file) for the current repository by inspecting the project and interviewing the user about the rules that actually matter. Use when the user says "set up CLAUDE.md", "write agent rules for this repo", "claude-md architect", or onboards a new project to Claude Code.

SKILL.md

3.3 KB, 748 tokens by cl100k_base, as published. Nobody here has run it

claude-md-architect — Build a CLAUDE.md that behaves like a filesystem, not a wish

Purpose

A great agent operating-rules file isn't prose — it's a tight set of constraints and pointers, weighted toward what the agent must NOT do, because that's where autonomous runs go wrong. This skill inspects the repo, extracts the rules implied by how the code is actually written, asks only the questions it can't infer, and writes a focused CLAUDE.md. It optimizes for signal-per-token: every line earns its place in the context window.

How to run

Inspect the repo (don't ask what you can read). Detect:
- language(s), package manager, build/test/lint/format commands (from package.json, pyproject, Makefile, CI config),
- directory conventions (where source/tests/scripts live),
- obvious house style (immutability? functional? naming patterns?) from 2–3 representative files,
- existing CLAUDE.md / .cursorrules / contributing docs to merge, not overwrite.
Interview — only the un-inferable. Ask at most 4–6 questions, e.g.:
- "What must the agent NEVER do here?" (deploy? touch migrations? edit generated files? commit to main?)
- "What's the definition of done — which command must pass?"
- "Any landmines — flaky areas, security-sensitive paths, do-not-touch dirs?"
- "Commit/PR conventions?"
Draft the CLAUDE.md using the structure below. Keep it under ~150 lines; link out to long material rather than inlining it.
Show it, refine once, write it to ./CLAUDE.md (or merge into the existing one, preserving the user's prior content).

The structure to generate

# <Project> — Agent Operating Rules

## Hard constraints (NEVER)
- <the things that cause real damage — deploy, secrets, force-push, generated files…>

## Definition of done
- <observable condition: e.g. `npm run verify` passes; the page renders>

## Commands
- build: <cmd>   test: <cmd>   lint: <cmd>   format: <cmd>

## House style (what "fits in" looks like here)
- <2–5 concrete, inferred rules — not generic platitudes>

## Layout & landmines
- <where things live; what's fragile; what to read before editing X>

## Workflow
- <branch/commit/PR conventions; when to ask vs proceed>

Principles (why this shape)

Constraint-first. The NEVER list goes at the top; prohibitions prevent the expensive mistakes a long autonomous run can make.
Inferred > asked. Anything readable from the repo is stated, not questioned — respect the user's time and avoid re-asking what the code already says.
Pointers over payloads. Link to deep docs; don't paste them. The file is loaded every session — keep it lean.
Observable done. "Done" must be a command or a visible state, never a vibe.

Notes

Never invent constraints. If you can't infer a rule and the user didn't give one, leave it out.
If a CLAUDE.md already exists, treat it as authoritative and augment it; show a diff.

Gives 0 of the 12 instructions most architecture codebase skills give in 748 tokens

Counted across 811 of the 1,134 authors here whose files we hold, read 2026-08-06

ask the user which candidate to explorein 46 of 811, across 16 files
apply the deletion test to suspected shallow modulesin 43 of 811, across 15 files
read any relevant architecture decision records firstin 31 of 811, across 7 files
use exact glossary terms in every suggestionin 29 of 811, across 9 files
accept dependencies instead of creating themin 24 of 811, across 5 files
include before and after visualisations for each candidatein 24 of 811, across 5 files
read the domain glossary before exploringin 24 of 811, across 6 files
return results instead of producing side effectsin 23 of 811, across 4 files
explore the codebase for shallow modules and frictionin 23 of 811, across 3 files
introduce seams only where things varyin 22 of 811, across 3 files
reduce the number of methodsin 21 of 811, across 2 files
design deep modules with small interfacesin 21 of 811, across 2 files

Said here and by no other author read

inspect the repository before asking questions
ask at most six un-inferable questions
keep the file under 150 lines
link to long material rather than inlining
list hard constraints at the top
make the definition of done an observable command or state

Grouped from the skills themselves: near-identical wordings counted once, and counted by distinct author, so one author publishing three of these counts once. Length counted with cl100k_base; the agent that loads this file may tokenize it differently.