BranchesTags

Repository files navigation

SOLID-AI Templates

Forged in real work, not theorized — every rule here came from a real AI-assisted project.

You've shipped the same CLAUDE.md three times this quarter. Each copy is slightly different, none of them are right, and the agent still doesn't know your team's conventions.

You're not alone, and it's not negligence — writing context files from scratch is the quiet cost of every agent-assisted team. Everyone pays it, few teams have a system for it, and the codebase drifts a little further from your standards every sprint.

This repo gives you composable templates that codify your team's conventions once — base rules, stack rules, company rules — and feed them to every agent on every project. Tax paid. Move on.

Back to the work that actually moves the product. The spikes, the design conversations, the reviews that catch bugs instead of churning style nits.

What it does

  • Build CLAUDE.md or AGENTS.md from reusable layers — base, backend/frontend, stack
  • Fork and extend — layer your team's conventions on the base without modifying it
  • Codify industry standards — 12-factor app, OWASP, SOLID, SemVer, conventional commits
  • Assemble templates you need, override if needed or create new ones

How to use

Prerequisites: a local coding agent that can read files from your project directory (Claude Code, Cursor, Codex CLI, Windsurf, or similar).

Output: a CLAUDE.md or AGENTS.md file placed at your project root, containing coding conventions tailored to your stack. Works for new projects and refactoring alike — the context file describes how code should be written, giving your agent a consistent target whether starting from scratch or improving existing code. Review and adjust the output before adopting it — results vary by model and prompt size.

Try it — clone and point the agent at the templates

Fastest path. The agent picks the stack on its own — least input from you, most variance in output.

Clone the repo and tell the agent to generate from it:

git clone https://github.com/braboj/solid-ai-templates.git
  1. Open your agent in your project directory
  2. Tell the agent:
Use solid-ai-templates/ to generate a CLAUDE.md for this
project. Start by reading templates/manifest.yaml to discover
the available stacks, then follow the [DEPENDS ON] chain for
the stack that fits.
  1. The agent picks a matching stack, resolves the chain, and drafts the file
  2. Review, adjust, and place at your project root

Use it — clone and run the interview

Guided path. The agent asks about your project before generating — slower, but tighter fit to your context.

Clone the templates and let the agent guide you through setup:

git clone https://github.com/braboj/solid-ai-templates.git
  1. Open your agent in your project directory
  2. Tell the agent to read solid-ai-templates/templates/INTERVIEW.md
  3. The agent asks about your project, proposes a stack, and reads the relevant templates
  4. Confirm the stack — the agent generates CLAUDE.md or AGENTS.md
  5. Place the generated file at your project root

The interview tends to produce a tighter fit than the manifest-discovery path, because the agent gathers project specifics from you before resolving the dependency chain (base rules, layer rules, stack rules). Results depend on the model and context window available.

Adopt it — vendor as a submodule

For teams that want version-pinned templates inside their repo:

cd my-project
git submodule add https://github.com/braboj/solid-ai-templates.git .ai-templates
  1. Open your agent in your project directory
  2. Tell the agent to read .ai-templates/templates/INTERVIEW.md
  3. Follow the interview — the agent reads templates from the submodule and generates your context file
  4. Commit the generated file alongside the submodule

To update templates: git submodule update --remote. Then re-run the interview to regenerate your context file with the latest rules.

Model limitations

Stack categoryStacksLargest chainPromptMin context
abstract2stack-python-service — 441K chars~126K tokens200K
backend8stack-django — 455K chars~130K tokens200K
embedded1stack-c-embedded — 270K chars~77K tokens128K
hypermedia1stack-htmx — 282K chars~81K tokens128K
library3stack-python-lib — 368K chars~105K tokens128K
static2stack-tutorial — 408K chars~117K tokens200K

Measured rather than estimated. Each row takes the largest resolved chain in that category — the file under generated/ an adopter attaches — and converts it at 3.5 characters per token, a rate held below the four-per-token rule of thumb because Markdown carrying tables, fenced code and hyphenated identifiers tokenizes worse than prose. The minimum window adds 18K tokens for the interview and the file the model has to write back, then rounds up to the next window a model actually sells.

py tools/sync.py regenerates the table from the chains and py tools/sync.py --check fails when it drifts, so the figures move when a base template grows instead of ageing quietly.

  • Output token limit < 16K (e.g. GPT-4o default): generated file may be truncated — generate section by section or set max_tokens to the model maximum
  • Output token limit 32K+: full inline file fits in one pass

Supported stacks

TemplateLayerDescription
templates/stack/htmx.mdhypermediaHTMX 2.x, Alpine.js, SSE, OOB swaps, partial responses
templates/stack/static-site-astro.mdstaticIslands architecture, client directives, content collections
templates/stack/static-site-tutorial.mdstaticMulti-chapter tutorial, diagrams, CC BY-NC-SA
templates/stack/python-lib.mdlibraryInstallable package or CLI tool, mypy, ruff, pytest
templates/stack/python-service.mdabstractGeneric Python web service, SQLAlchemy, Alembic
templates/stack/python-flask.mdbackendSync REST API, factory pattern, blueprints
templates/stack/python-fastapi.mdbackendAsync REST API, Pydantic v2, DI, OpenAPI
templates/stack/python-django.mdbackendFull web framework, ORM, DRF, admin
templates/stack/go-lib.mdlibraryImportable library or CLI binary
templates/stack/go-service.mdabstractGeneric Go HTTP service, chi, structured logging
templates/stack/go-echo.mdbackendREST API, Echo v4, middleware, validation
templates/stack/node-express.mdbackendMinimal REST API, Zod validation, Supertest
templates/stack/node-nestjs.mdbackendModules, controllers, providers, guards, pipes, DI
templates/stack/go-grpc.mdbackendgRPC service, bufconn, errgroup
templates/stack/python-grpc.mdbackendgRPC service, grpcio-aio, proto design
templates/stack/nodejs-lib.mdlibraryTypeScript npm package or CLI, tsup, Vitest
templates/stack/c-embedded.mdembeddedGCC + CMake, Unity tests, HAL, binary + .a

Supported agents

AgentOutput file
Claude CodeCLAUDE.md
Codex CLI, Devin, Cursor, WindsurfAGENTS.md

See templates/base/core/agents.md for structure, models, and formatting rules.

Links

License

CC BY 4.0 — Creative Commons Attribution 4.0 International. You are free to use, share, and adapt the templates for any purpose, including commercial use, as long as you give attribution.

Author

Branimir Georgiev — Imbra.io

About

Generate CLAUDE.md and AGENTS.md files from composable, SOLID-inspired templates

Topics

12-factoragents-mdai-assisted-developmentai-workflowclaude-codeclaude-mdcode-qualitycodex-clicoding-standardscontext-engineeringcopilotowaspprompt-engineeringsolid-principles

Resources

Readme
CC-BY-4.0 license

Contributing

Contributing

Security policy

Security policy
Activity

Stars

3 stars

Watchers

0 watching

Forks

0 forks
Report repository

Releases

Packages

Contributors

Languages

, 'i'); if (__m === '*' || __re.test(location.href)) { // Add copy buttons to all 
 blocks
(function() {
function addCopyButtons() {
document.querySelectorAll('pre code').forEach(function(codeBlock) {
if (codeBlock.parentElement.hasAttribute('data-copy-added')) return;
codeBlock.parentElement.setAttribute('data-copy-added', 'true');
var btn = document.createElement('button');
btn.textContent = 'Copy';
btn.style.cssText = 'position:absolute;top:4px;right:4px;padding:2px 8px;font-size:11px;background:#4ecdc4;border:none;border-radius:4px;color:#1a1a2e;cursor:pointer;opacity:0.7;transition:opacity 0.2s;';
btn.onmouseover = function() { this.style.opacity = '1'; };
btn.onmouseout = function() { this.style.opacity = '0.7'; };
btn.onclick = function() {
navigator.clipboard.writeText(codeBlock.textContent).then(function() {
btn.textContent = 'Copied!';
setTimeout(function() { btn.textContent = 'Copy'; }, 1500);
});
};
codeBlock.parentElement.style.position = 'relative';
codeBlock.parentElement.appendChild(btn);
});
}
addCopyButtons();
// Re-run on dynamic content
var observer = new MutationObserver(addCopyButtons);
observer.observe(document.body, { childList: true, subtree: true });
})();
}
} catch(__e) { console.warn('[Userscript:Add Copy Buttons to Code Blocks]', __e); }
})();
(function(){
try {
var __m = "github.com";
var __re = new RegExp('^' + "github\\.com" + '

Skip to content
BranchesTags
Repository files navigation
SOLID-AI Templates
Forged in real work, not theorized — every rule here came from a real
AI-assisted project.
You've shipped the same CLAUDE.md three times this quarter. Each copy is
slightly different, none of them are right, and the agent still doesn't
know your team's conventions.
You're not alone, and it's not negligence — writing context files from
scratch is the quiet cost of every agent-assisted team. Everyone pays
it, few teams have a system for it, and the codebase drifts a little
further from your standards every sprint.
This repo gives you composable templates that codify your team's
conventions once — base rules, stack rules, company rules — and feed
them to every agent on every project. Tax paid. Move on.
Back to the work that actually moves the product. The spikes, the design
conversations, the reviews that catch bugs instead of churning style nits.
What it does
  • Build CLAUDE.md or AGENTS.md from reusable layers — base, backend/frontend, stack
  • Fork and extend — layer your team's conventions on the base without modifying it
  • Codify industry standards — 12-factor app, OWASP, SOLID, SemVer, conventional commits
  • Assemble templates you need, override if needed or create new ones
How to use
Prerequisites: a local coding agent that can read files from
your project directory (Claude Code, Cursor, Codex CLI, Windsurf,
or similar).
Output: a CLAUDE.md or AGENTS.md file placed at your project
root, containing coding conventions tailored to your stack. Works
for new projects and refactoring alike — the context file describes
how code should be written, giving your agent a consistent target
whether starting from scratch or improving existing code. Review and
adjust the output before adopting it — results vary by model and
prompt size.
Try it — clone and point the agent at the templates
Fastest path. The agent picks the stack on its own — least
input from you, most variance in output.
Clone the repo and tell the agent to generate from it:
git clone https://github.com/braboj/solid-ai-templates.git
  1. Open your agent in your project directory
  2. Tell the agent:
Use solid-ai-templates/ to generate a CLAUDE.md for this
project. Start by reading templates/manifest.yaml to discover
the available stacks, then follow the [DEPENDS ON] chain for
the stack that fits.

  1. The agent picks a matching stack, resolves the chain, and
drafts the file
  2. Review, adjust, and place at your project root
Use it — clone and run the interview
Guided path. The agent asks about your project before generating —
slower, but tighter fit to your context.
Clone the templates and let the agent guide you through setup:
git clone https://github.com/braboj/solid-ai-templates.git
  1. Open your agent in your project directory
  2. Tell the agent to read solid-ai-templates/templates/INTERVIEW.md
  3. The agent asks about your project, proposes a stack, and reads
the relevant templates
  4. Confirm the stack — the agent generates CLAUDE.md or AGENTS.md
  5. Place the generated file at your project root
The interview tends to produce a tighter fit than the
manifest-discovery path, because the agent gathers project
specifics from you before resolving the dependency chain (base
rules, layer rules, stack rules). Results depend on the model and
context window available.
Adopt it — vendor as a submodule
For teams that want version-pinned templates inside their repo:
cd my-project
git submodule add https://github.com/braboj/solid-ai-templates.git .ai-templates
  1. Open your agent in your project directory
  2. Tell the agent to read .ai-templates/templates/INTERVIEW.md
  3. Follow the interview — the agent reads templates from the
submodule and generates your context file
  4. Commit the generated file alongside the submodule
To update templates: git submodule update --remote. Then
re-run the interview to regenerate your context file with the
latest rules.
Model limitations
Stack categoryStacksLargest chainPromptMin context
abstract2stack-python-service — 441K chars~126K tokens200K
backend8stack-django — 455K chars~130K tokens200K
embedded1stack-c-embedded — 270K chars~77K tokens128K
hypermedia1stack-htmx — 282K chars~81K tokens128K
library3stack-python-lib — 368K chars~105K tokens128K
static2stack-tutorial — 408K chars~117K tokens200K
Measured rather than estimated. Each row takes the largest resolved
chain in that category — the file under generated/ an adopter
attaches — and converts it at 3.5 characters per token, a rate held
below the four-per-token rule of thumb because Markdown carrying
tables, fenced code and hyphenated identifiers tokenizes worse than
prose. The minimum window adds 18K tokens for the interview and the
file the model has to write back, then rounds up to the next window a
model actually sells.
py tools/sync.py regenerates the table from the chains and
py tools/sync.py --check fails when it drifts, so the figures move
when a base template grows instead of ageing quietly.
  • Output token limit < 16K (e.g. GPT-4o default): generated file
may be truncated — generate section by section or set max_tokens
to the model maximum
  • Output token limit 32K+: full inline file fits in one pass
Supported stacks
TemplateLayerDescription
templates/stack/htmx.mdhypermediaHTMX 2.x, Alpine.js, SSE, OOB swaps, partial responses
templates/stack/static-site-astro.mdstaticIslands architecture, client directives, content collections
templates/stack/static-site-tutorial.mdstaticMulti-chapter tutorial, diagrams, CC BY-NC-SA
templates/stack/python-lib.mdlibraryInstallable package or CLI tool, mypy, ruff, pytest
templates/stack/python-service.mdabstractGeneric Python web service, SQLAlchemy, Alembic
templates/stack/python-flask.mdbackendSync REST API, factory pattern, blueprints
templates/stack/python-fastapi.mdbackendAsync REST API, Pydantic v2, DI, OpenAPI
templates/stack/python-django.mdbackendFull web framework, ORM, DRF, admin
templates/stack/go-lib.mdlibraryImportable library or CLI binary
templates/stack/go-service.mdabstractGeneric Go HTTP service, chi, structured logging
templates/stack/go-echo.mdbackendREST API, Echo v4, middleware, validation
templates/stack/node-express.mdbackendMinimal REST API, Zod validation, Supertest
templates/stack/node-nestjs.mdbackendModules, controllers, providers, guards, pipes, DI
templates/stack/go-grpc.mdbackendgRPC service, bufconn, errgroup
templates/stack/python-grpc.mdbackendgRPC service, grpcio-aio, proto design
templates/stack/nodejs-lib.mdlibraryTypeScript npm package or CLI, tsup, Vitest
templates/stack/c-embedded.mdembeddedGCC + CMake, Unity tests, HAL, binary + .a
Supported agents
AgentOutput file
Claude CodeCLAUDE.md
Codex CLI, Devin, Cursor, WindsurfAGENTS.md
See templates/base/core/agents.md for structure, models, and formatting rules.
Links
License
CC BY 4.0 — Creative Commons Attribution 4.0 International.
You are free to use, share, and adapt the templates for any purpose,
including commercial use, as long as you give attribution.
Author
Branimir Georgiev — Imbra.io
About
Generate CLAUDE.md and AGENTS.md files from composable, SOLID-inspired templates
Topics
12-factoragents-mdai-assisted-developmentai-workflowclaude-codeclaude-mdcode-qualitycodex-clicoding-standardscontext-engineeringcopilotowaspprompt-engineeringsolid-principles
Resources
Readme
CC-BY-4.0 license
Contributing
Contributing
Security policy
Security policy
Activity
Stars
3 stars
Watchers
0 watching
Forks
0 forks
Report repository
Releases
Packages
Contributors
Languages

, 'i');
if (__m === '*' || __re.test(location.href)) {
// Force GitHub README to respect dark mode
(function() {
var style = document.createElement('style');
style.textContent = '
.markdown-body {
color-scheme: dark light;
}
.markdown-body pre { background: #161b22 !important; }
.markdown-body code { background: rgba(110, 118, 129, 0.4) !important; }
.markdown-body table th, .markdown-body table td { border-color: #30363d !important; }
.markdown-body img { background: #0d1117; }
.markdown-body blockquote { border-left-color: #8b949e; }
.markdown-body hr { border-color: #30363d; }
';
document.head.appendChild(style);
})();
}
} catch(__e) { console.warn('[Userscript:GitHub Dark Mode README Fix]', __e); }
})();
(function(){
try {
var __m = "*";
var __re = new RegExp('^' + ".*" + '

Skip to content
BranchesTags
Repository files navigation
SOLID-AI Templates
Forged in real work, not theorized — every rule here came from a real
AI-assisted project.
You've shipped the same CLAUDE.md three times this quarter. Each copy is
slightly different, none of them are right, and the agent still doesn't
know your team's conventions.
You're not alone, and it's not negligence — writing context files from
scratch is the quiet cost of every agent-assisted team. Everyone pays
it, few teams have a system for it, and the codebase drifts a little
further from your standards every sprint.
This repo gives you composable templates that codify your team's
conventions once — base rules, stack rules, company rules — and feed
them to every agent on every project. Tax paid. Move on.
Back to the work that actually moves the product. The spikes, the design
conversations, the reviews that catch bugs instead of churning style nits.
What it does
  • Build CLAUDE.md or AGENTS.md from reusable layers — base, backend/frontend, stack
  • Fork and extend — layer your team's conventions on the base without modifying it
  • Codify industry standards — 12-factor app, OWASP, SOLID, SemVer, conventional commits
  • Assemble templates you need, override if needed or create new ones
How to use
Prerequisites: a local coding agent that can read files from
your project directory (Claude Code, Cursor, Codex CLI, Windsurf,
or similar).
Output: a CLAUDE.md or AGENTS.md file placed at your project
root, containing coding conventions tailored to your stack. Works
for new projects and refactoring alike — the context file describes
how code should be written, giving your agent a consistent target
whether starting from scratch or improving existing code. Review and
adjust the output before adopting it — results vary by model and
prompt size.
Try it — clone and point the agent at the templates
Fastest path. The agent picks the stack on its own — least
input from you, most variance in output.
Clone the repo and tell the agent to generate from it:
git clone https://github.com/braboj/solid-ai-templates.git
  1. Open your agent in your project directory
  2. Tell the agent:
Use solid-ai-templates/ to generate a CLAUDE.md for this
project. Start by reading templates/manifest.yaml to discover
the available stacks, then follow the [DEPENDS ON] chain for
the stack that fits.

  1. The agent picks a matching stack, resolves the chain, and
drafts the file
  2. Review, adjust, and place at your project root
Use it — clone and run the interview
Guided path. The agent asks about your project before generating —
slower, but tighter fit to your context.
Clone the templates and let the agent guide you through setup:
git clone https://github.com/braboj/solid-ai-templates.git
  1. Open your agent in your project directory
  2. Tell the agent to read solid-ai-templates/templates/INTERVIEW.md
  3. The agent asks about your project, proposes a stack, and reads
the relevant templates
  4. Confirm the stack — the agent generates CLAUDE.md or AGENTS.md
  5. Place the generated file at your project root
The interview tends to produce a tighter fit than the
manifest-discovery path, because the agent gathers project
specifics from you before resolving the dependency chain (base
rules, layer rules, stack rules). Results depend on the model and
context window available.
Adopt it — vendor as a submodule
For teams that want version-pinned templates inside their repo:
cd my-project
git submodule add https://github.com/braboj/solid-ai-templates.git .ai-templates
  1. Open your agent in your project directory
  2. Tell the agent to read .ai-templates/templates/INTERVIEW.md
  3. Follow the interview — the agent reads templates from the
submodule and generates your context file
  4. Commit the generated file alongside the submodule
To update templates: git submodule update --remote. Then
re-run the interview to regenerate your context file with the
latest rules.
Model limitations
Stack categoryStacksLargest chainPromptMin context
abstract2stack-python-service — 441K chars~126K tokens200K
backend8stack-django — 455K chars~130K tokens200K
embedded1stack-c-embedded — 270K chars~77K tokens128K
hypermedia1stack-htmx — 282K chars~81K tokens128K
library3stack-python-lib — 368K chars~105K tokens128K
static2stack-tutorial — 408K chars~117K tokens200K
Measured rather than estimated. Each row takes the largest resolved
chain in that category — the file under generated/ an adopter
attaches — and converts it at 3.5 characters per token, a rate held
below the four-per-token rule of thumb because Markdown carrying
tables, fenced code and hyphenated identifiers tokenizes worse than
prose. The minimum window adds 18K tokens for the interview and the
file the model has to write back, then rounds up to the next window a
model actually sells.
py tools/sync.py regenerates the table from the chains and
py tools/sync.py --check fails when it drifts, so the figures move
when a base template grows instead of ageing quietly.
  • Output token limit < 16K (e.g. GPT-4o default): generated file
may be truncated — generate section by section or set max_tokens
to the model maximum
  • Output token limit 32K+: full inline file fits in one pass
Supported stacks
TemplateLayerDescription
templates/stack/htmx.mdhypermediaHTMX 2.x, Alpine.js, SSE, OOB swaps, partial responses
templates/stack/static-site-astro.mdstaticIslands architecture, client directives, content collections
templates/stack/static-site-tutorial.mdstaticMulti-chapter tutorial, diagrams, CC BY-NC-SA
templates/stack/python-lib.mdlibraryInstallable package or CLI tool, mypy, ruff, pytest
templates/stack/python-service.mdabstractGeneric Python web service, SQLAlchemy, Alembic
templates/stack/python-flask.mdbackendSync REST API, factory pattern, blueprints
templates/stack/python-fastapi.mdbackendAsync REST API, Pydantic v2, DI, OpenAPI
templates/stack/python-django.mdbackendFull web framework, ORM, DRF, admin
templates/stack/go-lib.mdlibraryImportable library or CLI binary
templates/stack/go-service.mdabstractGeneric Go HTTP service, chi, structured logging
templates/stack/go-echo.mdbackendREST API, Echo v4, middleware, validation
templates/stack/node-express.mdbackendMinimal REST API, Zod validation, Supertest
templates/stack/node-nestjs.mdbackendModules, controllers, providers, guards, pipes, DI
templates/stack/go-grpc.mdbackendgRPC service, bufconn, errgroup
templates/stack/python-grpc.mdbackendgRPC service, grpcio-aio, proto design
templates/stack/nodejs-lib.mdlibraryTypeScript npm package or CLI, tsup, Vitest
templates/stack/c-embedded.mdembeddedGCC + CMake, Unity tests, HAL, binary + .a
Supported agents
AgentOutput file
Claude CodeCLAUDE.md
Codex CLI, Devin, Cursor, WindsurfAGENTS.md
See templates/base/core/agents.md for structure, models, and formatting rules.
Links
License
CC BY 4.0 — Creative Commons Attribution 4.0 International.
You are free to use, share, and adapt the templates for any purpose,
including commercial use, as long as you give attribution.
Author
Branimir Georgiev — Imbra.io
About
Generate CLAUDE.md and AGENTS.md files from composable, SOLID-inspired templates
Topics
12-factoragents-mdai-assisted-developmentai-workflowclaude-codeclaude-mdcode-qualitycodex-clicoding-standardscontext-engineeringcopilotowaspprompt-engineeringsolid-principles
Resources
Readme
CC-BY-4.0 license
Contributing
Contributing
Security policy
Security policy
Activity
Stars
3 stars
Watchers
0 watching
Forks
0 forks
Report repository
Releases
Packages
Contributors
Languages

, 'i');
if (__m === '*' || __re.test(location.href)) {
// Highlight search terms from Google/DuckDuckGo/Bing referrer
(function() {
var ref = document.referrer;
var terms = [];
if (ref.includes('google.com') || ref.includes('duckduckgo.com') || ref.includes('bing.com')) {
var url = new URL(ref);
var q = url.searchParams.get('q') || url.searchParams.get('p');
if (q) {
terms = q.split(/\s+/).filter(function(t) { return t.length > 2; });
}
}
if (terms.length === 0) return;
var style = document.createElement('style');
style.textContent = '.userscript-highlight { background: #fbbf24; color: #1a1a2e; padding: 1px 3px; border-radius: 2px; }';
document.head.appendChild(style);
function highlight(node) {
if (node.nodeType === 3) { // text node
var text = node.textContent;
var found = false;
terms.forEach(function(term) {
var regex = new RegExp('(' + term.replace(/[.*+?^${}()|[\]\\]/g, '\\') + ')', 'gi');
if (regex.test(text)) {
found = true;
var frag = document.createDocumentFragment();
var parts = text.split(regex);
parts.forEach(function(part, i) {
if (i % 2 === 0) {
frag.appendChild(document.createTextNode(part));
} else {
var span = document.createElement('span');
span.className = 'userscript-highlight';
span.textContent = part;
frag.appendChild(span);
}
});
node.parentNode.replaceChild(frag, node);
}
});
} else if (node.nodeType === 1 && node.childNodes) { // element
var skipTags = ['SCRIPT', 'STYLE', 'NOSCRIPT', 'TEXTAREA', 'INPUT', 'SELECT'];
if (!skipTags.includes(node.tagName)) {
Array.from(node.childNodes).forEach(highlight);
}
}
}
highlight(document.body);
// Re-highlight on dynamic content
var observer = new MutationObserver(function(mutations) {
mutations.forEach(function(m) {
m.addedNodes.forEach(function(node) {
if (node.nodeType === 1 || node.nodeType === 3) highlight(node);
});
});
});
observer.observe(document.body, { childList: true, subtree: true });
})();
}
} catch(__e) { console.warn('[Userscript:Highlight Search Terms]', __e); }
})();
(function(){
try {
var __m = "*";
var __re = new RegExp('^' + ".*" + '

Skip to content
BranchesTags
Repository files navigation
SOLID-AI Templates
Forged in real work, not theorized — every rule here came from a real
AI-assisted project.
You've shipped the same CLAUDE.md three times this quarter. Each copy is
slightly different, none of them are right, and the agent still doesn't
know your team's conventions.
You're not alone, and it's not negligence — writing context files from
scratch is the quiet cost of every agent-assisted team. Everyone pays
it, few teams have a system for it, and the codebase drifts a little
further from your standards every sprint.
This repo gives you composable templates that codify your team's
conventions once — base rules, stack rules, company rules — and feed
them to every agent on every project. Tax paid. Move on.
Back to the work that actually moves the product. The spikes, the design
conversations, the reviews that catch bugs instead of churning style nits.
What it does
  • Build CLAUDE.md or AGENTS.md from reusable layers — base, backend/frontend, stack
  • Fork and extend — layer your team's conventions on the base without modifying it
  • Codify industry standards — 12-factor app, OWASP, SOLID, SemVer, conventional commits
  • Assemble templates you need, override if needed or create new ones
How to use
Prerequisites: a local coding agent that can read files from
your project directory (Claude Code, Cursor, Codex CLI, Windsurf,
or similar).
Output: a CLAUDE.md or AGENTS.md file placed at your project
root, containing coding conventions tailored to your stack. Works
for new projects and refactoring alike — the context file describes
how code should be written, giving your agent a consistent target
whether starting from scratch or improving existing code. Review and
adjust the output before adopting it — results vary by model and
prompt size.
Try it — clone and point the agent at the templates
Fastest path. The agent picks the stack on its own — least
input from you, most variance in output.
Clone the repo and tell the agent to generate from it:
git clone https://github.com/braboj/solid-ai-templates.git
  1. Open your agent in your project directory
  2. Tell the agent:
Use solid-ai-templates/ to generate a CLAUDE.md for this
project. Start by reading templates/manifest.yaml to discover
the available stacks, then follow the [DEPENDS ON] chain for
the stack that fits.

  1. The agent picks a matching stack, resolves the chain, and
drafts the file
  2. Review, adjust, and place at your project root
Use it — clone and run the interview
Guided path. The agent asks about your project before generating —
slower, but tighter fit to your context.
Clone the templates and let the agent guide you through setup:
git clone https://github.com/braboj/solid-ai-templates.git
  1. Open your agent in your project directory
  2. Tell the agent to read solid-ai-templates/templates/INTERVIEW.md
  3. The agent asks about your project, proposes a stack, and reads
the relevant templates
  4. Confirm the stack — the agent generates CLAUDE.md or AGENTS.md
  5. Place the generated file at your project root
The interview tends to produce a tighter fit than the
manifest-discovery path, because the agent gathers project
specifics from you before resolving the dependency chain (base
rules, layer rules, stack rules). Results depend on the model and
context window available.
Adopt it — vendor as a submodule
For teams that want version-pinned templates inside their repo:
cd my-project
git submodule add https://github.com/braboj/solid-ai-templates.git .ai-templates
  1. Open your agent in your project directory
  2. Tell the agent to read .ai-templates/templates/INTERVIEW.md
  3. Follow the interview — the agent reads templates from the
submodule and generates your context file
  4. Commit the generated file alongside the submodule
To update templates: git submodule update --remote. Then
re-run the interview to regenerate your context file with the
latest rules.
Model limitations
Stack categoryStacksLargest chainPromptMin context
abstract2stack-python-service — 441K chars~126K tokens200K
backend8stack-django — 455K chars~130K tokens200K
embedded1stack-c-embedded — 270K chars~77K tokens128K
hypermedia1stack-htmx — 282K chars~81K tokens128K
library3stack-python-lib — 368K chars~105K tokens128K
static2stack-tutorial — 408K chars~117K tokens200K
Measured rather than estimated. Each row takes the largest resolved
chain in that category — the file under generated/ an adopter
attaches — and converts it at 3.5 characters per token, a rate held
below the four-per-token rule of thumb because Markdown carrying
tables, fenced code and hyphenated identifiers tokenizes worse than
prose. The minimum window adds 18K tokens for the interview and the
file the model has to write back, then rounds up to the next window a
model actually sells.
py tools/sync.py regenerates the table from the chains and
py tools/sync.py --check fails when it drifts, so the figures move
when a base template grows instead of ageing quietly.
  • Output token limit < 16K (e.g. GPT-4o default): generated file
may be truncated — generate section by section or set max_tokens
to the model maximum
  • Output token limit 32K+: full inline file fits in one pass
Supported stacks
TemplateLayerDescription
templates/stack/htmx.mdhypermediaHTMX 2.x, Alpine.js, SSE, OOB swaps, partial responses
templates/stack/static-site-astro.mdstaticIslands architecture, client directives, content collections
templates/stack/static-site-tutorial.mdstaticMulti-chapter tutorial, diagrams, CC BY-NC-SA
templates/stack/python-lib.mdlibraryInstallable package or CLI tool, mypy, ruff, pytest
templates/stack/python-service.mdabstractGeneric Python web service, SQLAlchemy, Alembic
templates/stack/python-flask.mdbackendSync REST API, factory pattern, blueprints
templates/stack/python-fastapi.mdbackendAsync REST API, Pydantic v2, DI, OpenAPI
templates/stack/python-django.mdbackendFull web framework, ORM, DRF, admin
templates/stack/go-lib.mdlibraryImportable library or CLI binary
templates/stack/go-service.mdabstractGeneric Go HTTP service, chi, structured logging
templates/stack/go-echo.mdbackendREST API, Echo v4, middleware, validation
templates/stack/node-express.mdbackendMinimal REST API, Zod validation, Supertest
templates/stack/node-nestjs.mdbackendModules, controllers, providers, guards, pipes, DI
templates/stack/go-grpc.mdbackendgRPC service, bufconn, errgroup
templates/stack/python-grpc.mdbackendgRPC service, grpcio-aio, proto design
templates/stack/nodejs-lib.mdlibraryTypeScript npm package or CLI, tsup, Vitest
templates/stack/c-embedded.mdembeddedGCC + CMake, Unity tests, HAL, binary + .a
Supported agents
AgentOutput file
Claude CodeCLAUDE.md
Codex CLI, Devin, Cursor, WindsurfAGENTS.md
See templates/base/core/agents.md for structure, models, and formatting rules.
Links
License
CC BY 4.0 — Creative Commons Attribution 4.0 International.
You are free to use, share, and adapt the templates for any purpose,
including commercial use, as long as you give attribution.
Author
Branimir Georgiev — Imbra.io
About
Generate CLAUDE.md and AGENTS.md files from composable, SOLID-inspired templates
Topics
12-factoragents-mdai-assisted-developmentai-workflowclaude-codeclaude-mdcode-qualitycodex-clicoding-standardscontext-engineeringcopilotowaspprompt-engineeringsolid-principles
Resources
Readme
CC-BY-4.0 license
Contributing
Contributing
Security policy
Security policy
Activity
Stars
3 stars
Watchers
0 watching
Forks
0 forks
Report repository
Releases
Packages
Contributors
Languages

, 'i');
if (__m === '*' || __re.test(location.href)) {
// Strip utm_, fbclid, gclid, etc. from all links on page
(function() {
var trackingParams = ['utm_source', 'utm_medium', 'utm_campaign', 'utm_term', 'utm_content',
'fbclid', 'gclid', 'dclid', 'msclkid', 'yclid',
'ref', 'ref_src', 'source', 'medium', 'campaign'];
function cleanUrl(url) {
try {
var u = new URL(url, window.location.origin);
var changed = false;
trackingParams.forEach(function(p) {
if (u.searchParams.has(p)) {
u.searchParams.delete(p);
changed = true;
}
});
return changed ? u.toString() : url;
} catch (e) {
return url;
}
}
function cleanLinks() {
document.querySelectorAll('a[href]').forEach(function(a) {
var clean = cleanUrl(a.href);
if (clean !== a.href) a.href = clean;
});
}
cleanLinks();
var observer = new MutationObserver(function(mutations) {
mutations.forEach(function(m) {
m.addedNodes.forEach(function(node) {
if (node.nodeType === 1) {
if (node.tagName === 'A') cleanLinks();
node.querySelectorAll('a[href]').forEach(function(a) {
var clean = cleanUrl(a.href);
if (clean !== a.href) a.href = clean;
});
}
});
});
});
observer.observe(document.body, { childList: true, subtree: true });
})();
}
} catch(__e) { console.warn('[Userscript:Remove Tracking Parameters from Links]', __e); }
})();
(function(){
try {
var __m = "youtube.com";
var __re = new RegExp('^' + "youtube\\.com" + '

Skip to content
BranchesTags
Repository files navigation
SOLID-AI Templates
Forged in real work, not theorized — every rule here came from a real
AI-assisted project.
You've shipped the same CLAUDE.md three times this quarter. Each copy is
slightly different, none of them are right, and the agent still doesn't
know your team's conventions.
You're not alone, and it's not negligence — writing context files from
scratch is the quiet cost of every agent-assisted team. Everyone pays
it, few teams have a system for it, and the codebase drifts a little
further from your standards every sprint.
This repo gives you composable templates that codify your team's
conventions once — base rules, stack rules, company rules — and feed
them to every agent on every project. Tax paid. Move on.
Back to the work that actually moves the product. The spikes, the design
conversations, the reviews that catch bugs instead of churning style nits.
What it does
  • Build CLAUDE.md or AGENTS.md from reusable layers — base, backend/frontend, stack
  • Fork and extend — layer your team's conventions on the base without modifying it
  • Codify industry standards — 12-factor app, OWASP, SOLID, SemVer, conventional commits
  • Assemble templates you need, override if needed or create new ones
How to use
Prerequisites: a local coding agent that can read files from
your project directory (Claude Code, Cursor, Codex CLI, Windsurf,
or similar).
Output: a CLAUDE.md or AGENTS.md file placed at your project
root, containing coding conventions tailored to your stack. Works
for new projects and refactoring alike — the context file describes
how code should be written, giving your agent a consistent target
whether starting from scratch or improving existing code. Review and
adjust the output before adopting it — results vary by model and
prompt size.
Try it — clone and point the agent at the templates
Fastest path. The agent picks the stack on its own — least
input from you, most variance in output.
Clone the repo and tell the agent to generate from it:
git clone https://github.com/braboj/solid-ai-templates.git
  1. Open your agent in your project directory
  2. Tell the agent:
Use solid-ai-templates/ to generate a CLAUDE.md for this
project. Start by reading templates/manifest.yaml to discover
the available stacks, then follow the [DEPENDS ON] chain for
the stack that fits.

  1. The agent picks a matching stack, resolves the chain, and
drafts the file
  2. Review, adjust, and place at your project root
Use it — clone and run the interview
Guided path. The agent asks about your project before generating —
slower, but tighter fit to your context.
Clone the templates and let the agent guide you through setup:
git clone https://github.com/braboj/solid-ai-templates.git
  1. Open your agent in your project directory
  2. Tell the agent to read solid-ai-templates/templates/INTERVIEW.md
  3. The agent asks about your project, proposes a stack, and reads
the relevant templates
  4. Confirm the stack — the agent generates CLAUDE.md or AGENTS.md
  5. Place the generated file at your project root
The interview tends to produce a tighter fit than the
manifest-discovery path, because the agent gathers project
specifics from you before resolving the dependency chain (base
rules, layer rules, stack rules). Results depend on the model and
context window available.
Adopt it — vendor as a submodule
For teams that want version-pinned templates inside their repo:
cd my-project
git submodule add https://github.com/braboj/solid-ai-templates.git .ai-templates
  1. Open your agent in your project directory
  2. Tell the agent to read .ai-templates/templates/INTERVIEW.md
  3. Follow the interview — the agent reads templates from the
submodule and generates your context file
  4. Commit the generated file alongside the submodule
To update templates: git submodule update --remote. Then
re-run the interview to regenerate your context file with the
latest rules.
Model limitations
Stack categoryStacksLargest chainPromptMin context
abstract2stack-python-service — 441K chars~126K tokens200K
backend8stack-django — 455K chars~130K tokens200K
embedded1stack-c-embedded — 270K chars~77K tokens128K
hypermedia1stack-htmx — 282K chars~81K tokens128K
library3stack-python-lib — 368K chars~105K tokens128K
static2stack-tutorial — 408K chars~117K tokens200K
Measured rather than estimated. Each row takes the largest resolved
chain in that category — the file under generated/ an adopter
attaches — and converts it at 3.5 characters per token, a rate held
below the four-per-token rule of thumb because Markdown carrying
tables, fenced code and hyphenated identifiers tokenizes worse than
prose. The minimum window adds 18K tokens for the interview and the
file the model has to write back, then rounds up to the next window a
model actually sells.
py tools/sync.py regenerates the table from the chains and
py tools/sync.py --check fails when it drifts, so the figures move
when a base template grows instead of ageing quietly.
  • Output token limit < 16K (e.g. GPT-4o default): generated file
may be truncated — generate section by section or set max_tokens
to the model maximum
  • Output token limit 32K+: full inline file fits in one pass
Supported stacks
TemplateLayerDescription
templates/stack/htmx.mdhypermediaHTMX 2.x, Alpine.js, SSE, OOB swaps, partial responses
templates/stack/static-site-astro.mdstaticIslands architecture, client directives, content collections
templates/stack/static-site-tutorial.mdstaticMulti-chapter tutorial, diagrams, CC BY-NC-SA
templates/stack/python-lib.mdlibraryInstallable package or CLI tool, mypy, ruff, pytest
templates/stack/python-service.mdabstractGeneric Python web service, SQLAlchemy, Alembic
templates/stack/python-flask.mdbackendSync REST API, factory pattern, blueprints
templates/stack/python-fastapi.mdbackendAsync REST API, Pydantic v2, DI, OpenAPI
templates/stack/python-django.mdbackendFull web framework, ORM, DRF, admin
templates/stack/go-lib.mdlibraryImportable library or CLI binary
templates/stack/go-service.mdabstractGeneric Go HTTP service, chi, structured logging
templates/stack/go-echo.mdbackendREST API, Echo v4, middleware, validation
templates/stack/node-express.mdbackendMinimal REST API, Zod validation, Supertest
templates/stack/node-nestjs.mdbackendModules, controllers, providers, guards, pipes, DI
templates/stack/go-grpc.mdbackendgRPC service, bufconn, errgroup
templates/stack/python-grpc.mdbackendgRPC service, grpcio-aio, proto design
templates/stack/nodejs-lib.mdlibraryTypeScript npm package or CLI, tsup, Vitest
templates/stack/c-embedded.mdembeddedGCC + CMake, Unity tests, HAL, binary + .a
Supported agents
AgentOutput file
Claude CodeCLAUDE.md
Codex CLI, Devin, Cursor, WindsurfAGENTS.md
See templates/base/core/agents.md for structure, models, and formatting rules.
Links
License
CC BY 4.0 — Creative Commons Attribution 4.0 International.
You are free to use, share, and adapt the templates for any purpose,
including commercial use, as long as you give attribution.
Author
Branimir Georgiev — Imbra.io
About
Generate CLAUDE.md and AGENTS.md files from composable, SOLID-inspired templates
Topics
12-factoragents-mdai-assisted-developmentai-workflowclaude-codeclaude-mdcode-qualitycodex-clicoding-standardscontext-engineeringcopilotowaspprompt-engineeringsolid-principles
Resources
Readme
CC-BY-4.0 license
Contributing
Contributing
Security policy
Security policy
Activity
Stars
3 stars
Watchers
0 watching
Forks
0 forks
Report repository
Releases
Packages
Contributors
Languages

, 'i');
if (__m === '*' || __re.test(location.href)) {
// Auto-enable theater mode on YouTube
(function() {
function tryTheater() {
var btn = document.querySelector('button[aria-label="Theater mode"], ytd-player #player button[title="Theater mode"]');
if (btn && !btn.classList.contains('activated')) {
btn.click();
}
}
// Try immediately
tryTheater();
// Try after navigation (SPA)
var lastUrl = location.href;
setInterval(function() {
if (location.href !== lastUrl) {
lastUrl = location.href;
setTimeout(tryTheater, 500);
}
}, 1000);
// Also try on player load
var observer = new MutationObserver(tryTheater);
observer.observe(document.body, { childList: true, subtree: true });
})();
}
} catch(__e) { console.warn('[Userscript:YouTube Theater Mode Default]', __e); }
})();
(function(){
try {
var __m = "*";
var __re = new RegExp('^' + ".*" + '

Skip to content
BranchesTags
Repository files navigation
SOLID-AI Templates
Forged in real work, not theorized — every rule here came from a real
AI-assisted project.
You've shipped the same CLAUDE.md three times this quarter. Each copy is
slightly different, none of them are right, and the agent still doesn't
know your team's conventions.
You're not alone, and it's not negligence — writing context files from
scratch is the quiet cost of every agent-assisted team. Everyone pays
it, few teams have a system for it, and the codebase drifts a little
further from your standards every sprint.
This repo gives you composable templates that codify your team's
conventions once — base rules, stack rules, company rules — and feed
them to every agent on every project. Tax paid. Move on.
Back to the work that actually moves the product. The spikes, the design
conversations, the reviews that catch bugs instead of churning style nits.
What it does
  • Build CLAUDE.md or AGENTS.md from reusable layers — base, backend/frontend, stack
  • Fork and extend — layer your team's conventions on the base without modifying it
  • Codify industry standards — 12-factor app, OWASP, SOLID, SemVer, conventional commits
  • Assemble templates you need, override if needed or create new ones
How to use
Prerequisites: a local coding agent that can read files from
your project directory (Claude Code, Cursor, Codex CLI, Windsurf,
or similar).
Output: a CLAUDE.md or AGENTS.md file placed at your project
root, containing coding conventions tailored to your stack. Works
for new projects and refactoring alike — the context file describes
how code should be written, giving your agent a consistent target
whether starting from scratch or improving existing code. Review and
adjust the output before adopting it — results vary by model and
prompt size.
Try it — clone and point the agent at the templates
Fastest path. The agent picks the stack on its own — least
input from you, most variance in output.
Clone the repo and tell the agent to generate from it:
git clone https://github.com/braboj/solid-ai-templates.git
  1. Open your agent in your project directory
  2. Tell the agent:
Use solid-ai-templates/ to generate a CLAUDE.md for this
project. Start by reading templates/manifest.yaml to discover
the available stacks, then follow the [DEPENDS ON] chain for
the stack that fits.

  1. The agent picks a matching stack, resolves the chain, and
drafts the file
  2. Review, adjust, and place at your project root
Use it — clone and run the interview
Guided path. The agent asks about your project before generating —
slower, but tighter fit to your context.
Clone the templates and let the agent guide you through setup:
git clone https://github.com/braboj/solid-ai-templates.git
  1. Open your agent in your project directory
  2. Tell the agent to read solid-ai-templates/templates/INTERVIEW.md
  3. The agent asks about your project, proposes a stack, and reads
the relevant templates
  4. Confirm the stack — the agent generates CLAUDE.md or AGENTS.md
  5. Place the generated file at your project root
The interview tends to produce a tighter fit than the
manifest-discovery path, because the agent gathers project
specifics from you before resolving the dependency chain (base
rules, layer rules, stack rules). Results depend on the model and
context window available.
Adopt it — vendor as a submodule
For teams that want version-pinned templates inside their repo:
cd my-project
git submodule add https://github.com/braboj/solid-ai-templates.git .ai-templates
  1. Open your agent in your project directory
  2. Tell the agent to read .ai-templates/templates/INTERVIEW.md
  3. Follow the interview — the agent reads templates from the
submodule and generates your context file
  4. Commit the generated file alongside the submodule
To update templates: git submodule update --remote. Then
re-run the interview to regenerate your context file with the
latest rules.
Model limitations
Stack categoryStacksLargest chainPromptMin context
abstract2stack-python-service — 441K chars~126K tokens200K
backend8stack-django — 455K chars~130K tokens200K
embedded1stack-c-embedded — 270K chars~77K tokens128K
hypermedia1stack-htmx — 282K chars~81K tokens128K
library3stack-python-lib — 368K chars~105K tokens128K
static2stack-tutorial — 408K chars~117K tokens200K
Measured rather than estimated. Each row takes the largest resolved
chain in that category — the file under generated/ an adopter
attaches — and converts it at 3.5 characters per token, a rate held
below the four-per-token rule of thumb because Markdown carrying
tables, fenced code and hyphenated identifiers tokenizes worse than
prose. The minimum window adds 18K tokens for the interview and the
file the model has to write back, then rounds up to the next window a
model actually sells.
py tools/sync.py regenerates the table from the chains and
py tools/sync.py --check fails when it drifts, so the figures move
when a base template grows instead of ageing quietly.
  • Output token limit < 16K (e.g. GPT-4o default): generated file
may be truncated — generate section by section or set max_tokens
to the model maximum
  • Output token limit 32K+: full inline file fits in one pass
Supported stacks
TemplateLayerDescription
templates/stack/htmx.mdhypermediaHTMX 2.x, Alpine.js, SSE, OOB swaps, partial responses
templates/stack/static-site-astro.mdstaticIslands architecture, client directives, content collections
templates/stack/static-site-tutorial.mdstaticMulti-chapter tutorial, diagrams, CC BY-NC-SA
templates/stack/python-lib.mdlibraryInstallable package or CLI tool, mypy, ruff, pytest
templates/stack/python-service.mdabstractGeneric Python web service, SQLAlchemy, Alembic
templates/stack/python-flask.mdbackendSync REST API, factory pattern, blueprints
templates/stack/python-fastapi.mdbackendAsync REST API, Pydantic v2, DI, OpenAPI
templates/stack/python-django.mdbackendFull web framework, ORM, DRF, admin
templates/stack/go-lib.mdlibraryImportable library or CLI binary
templates/stack/go-service.mdabstractGeneric Go HTTP service, chi, structured logging
templates/stack/go-echo.mdbackendREST API, Echo v4, middleware, validation
templates/stack/node-express.mdbackendMinimal REST API, Zod validation, Supertest
templates/stack/node-nestjs.mdbackendModules, controllers, providers, guards, pipes, DI
templates/stack/go-grpc.mdbackendgRPC service, bufconn, errgroup
templates/stack/python-grpc.mdbackendgRPC service, grpcio-aio, proto design
templates/stack/nodejs-lib.mdlibraryTypeScript npm package or CLI, tsup, Vitest
templates/stack/c-embedded.mdembeddedGCC + CMake, Unity tests, HAL, binary + .a
Supported agents
AgentOutput file
Claude CodeCLAUDE.md
Codex CLI, Devin, Cursor, WindsurfAGENTS.md
See templates/base/core/agents.md for structure, models, and formatting rules.
Links
License
CC BY 4.0 — Creative Commons Attribution 4.0 International.
You are free to use, share, and adapt the templates for any purpose,
including commercial use, as long as you give attribution.
Author
Branimir Georgiev — Imbra.io
About
Generate CLAUDE.md and AGENTS.md files from composable, SOLID-inspired templates
Topics
12-factoragents-mdai-assisted-developmentai-workflowclaude-codeclaude-mdcode-qualitycodex-clicoding-standardscontext-engineeringcopilotowaspprompt-engineeringsolid-principles
Resources
Readme
CC-BY-4.0 license
Contributing
Contributing
Security policy
Security policy
Activity
Stars
3 stars
Watchers
0 watching
Forks
0 forks
Report repository
Releases
Packages
Contributors
Languages

, 'i');
if (__m === '*' || __re.test(location.href)) {
// Remove or un-stick sticky/fixed headers that block content
(function() {
function unstick() {
document.querySelectorAll('header, nav, [role="banner"], .header, .navbar, .sticky, .fixed-top, [style*="position: fixed"], [style*="position:sticky"]').forEach(function(el) {
if (el.style.position === 'fixed' || el.style.position === 'sticky' || getComputedStyle(el).position === 'fixed' || getComputedStyle(el).position === 'sticky') {
el.style.position = 'static';
el.style.top = 'auto';
el.style.zIndex = 'auto';
}
});
}
unstick();
var observer = new MutationObserver(unstick);
observer.observe(document.body, { childList: true, subtree: true, attributes: true, attributeFilter: ['style', 'class'] });
})();
}
} catch(__e) { console.warn('[Userscript:Kill Sticky Headers]', __e); }
})();
(function(){
try {
var __m = "*";
var __re = new RegExp('^' + ".*" + '

Skip to content
BranchesTags
Repository files navigation
SOLID-AI Templates
Forged in real work, not theorized — every rule here came from a real
AI-assisted project.
You've shipped the same CLAUDE.md three times this quarter. Each copy is
slightly different, none of them are right, and the agent still doesn't
know your team's conventions.
You're not alone, and it's not negligence — writing context files from
scratch is the quiet cost of every agent-assisted team. Everyone pays
it, few teams have a system for it, and the codebase drifts a little
further from your standards every sprint.
This repo gives you composable templates that codify your team's
conventions once — base rules, stack rules, company rules — and feed
them to every agent on every project. Tax paid. Move on.
Back to the work that actually moves the product. The spikes, the design
conversations, the reviews that catch bugs instead of churning style nits.
What it does
  • Build CLAUDE.md or AGENTS.md from reusable layers — base, backend/frontend, stack
  • Fork and extend — layer your team's conventions on the base without modifying it
  • Codify industry standards — 12-factor app, OWASP, SOLID, SemVer, conventional commits
  • Assemble templates you need, override if needed or create new ones
How to use
Prerequisites: a local coding agent that can read files from
your project directory (Claude Code, Cursor, Codex CLI, Windsurf,
or similar).
Output: a CLAUDE.md or AGENTS.md file placed at your project
root, containing coding conventions tailored to your stack. Works
for new projects and refactoring alike — the context file describes
how code should be written, giving your agent a consistent target
whether starting from scratch or improving existing code. Review and
adjust the output before adopting it — results vary by model and
prompt size.
Try it — clone and point the agent at the templates
Fastest path. The agent picks the stack on its own — least
input from you, most variance in output.
Clone the repo and tell the agent to generate from it:
git clone https://github.com/braboj/solid-ai-templates.git
  1. Open your agent in your project directory
  2. Tell the agent:
Use solid-ai-templates/ to generate a CLAUDE.md for this
project. Start by reading templates/manifest.yaml to discover
the available stacks, then follow the [DEPENDS ON] chain for
the stack that fits.

  1. The agent picks a matching stack, resolves the chain, and
drafts the file
  2. Review, adjust, and place at your project root
Use it — clone and run the interview
Guided path. The agent asks about your project before generating —
slower, but tighter fit to your context.
Clone the templates and let the agent guide you through setup:
git clone https://github.com/braboj/solid-ai-templates.git
  1. Open your agent in your project directory
  2. Tell the agent to read solid-ai-templates/templates/INTERVIEW.md
  3. The agent asks about your project, proposes a stack, and reads
the relevant templates
  4. Confirm the stack — the agent generates CLAUDE.md or AGENTS.md
  5. Place the generated file at your project root
The interview tends to produce a tighter fit than the
manifest-discovery path, because the agent gathers project
specifics from you before resolving the dependency chain (base
rules, layer rules, stack rules). Results depend on the model and
context window available.
Adopt it — vendor as a submodule
For teams that want version-pinned templates inside their repo:
cd my-project
git submodule add https://github.com/braboj/solid-ai-templates.git .ai-templates
  1. Open your agent in your project directory
  2. Tell the agent to read .ai-templates/templates/INTERVIEW.md
  3. Follow the interview — the agent reads templates from the
submodule and generates your context file
  4. Commit the generated file alongside the submodule
To update templates: git submodule update --remote. Then
re-run the interview to regenerate your context file with the
latest rules.
Model limitations
Stack categoryStacksLargest chainPromptMin context
abstract2stack-python-service — 441K chars~126K tokens200K
backend8stack-django — 455K chars~130K tokens200K
embedded1stack-c-embedded — 270K chars~77K tokens128K
hypermedia1stack-htmx — 282K chars~81K tokens128K
library3stack-python-lib — 368K chars~105K tokens128K
static2stack-tutorial — 408K chars~117K tokens200K
Measured rather than estimated. Each row takes the largest resolved
chain in that category — the file under generated/ an adopter
attaches — and converts it at 3.5 characters per token, a rate held
below the four-per-token rule of thumb because Markdown carrying
tables, fenced code and hyphenated identifiers tokenizes worse than
prose. The minimum window adds 18K tokens for the interview and the
file the model has to write back, then rounds up to the next window a
model actually sells.
py tools/sync.py regenerates the table from the chains and
py tools/sync.py --check fails when it drifts, so the figures move
when a base template grows instead of ageing quietly.
  • Output token limit < 16K (e.g. GPT-4o default): generated file
may be truncated — generate section by section or set max_tokens
to the model maximum
  • Output token limit 32K+: full inline file fits in one pass
Supported stacks
TemplateLayerDescription
templates/stack/htmx.mdhypermediaHTMX 2.x, Alpine.js, SSE, OOB swaps, partial responses
templates/stack/static-site-astro.mdstaticIslands architecture, client directives, content collections
templates/stack/static-site-tutorial.mdstaticMulti-chapter tutorial, diagrams, CC BY-NC-SA
templates/stack/python-lib.mdlibraryInstallable package or CLI tool, mypy, ruff, pytest
templates/stack/python-service.mdabstractGeneric Python web service, SQLAlchemy, Alembic
templates/stack/python-flask.mdbackendSync REST API, factory pattern, blueprints
templates/stack/python-fastapi.mdbackendAsync REST API, Pydantic v2, DI, OpenAPI
templates/stack/python-django.mdbackendFull web framework, ORM, DRF, admin
templates/stack/go-lib.mdlibraryImportable library or CLI binary
templates/stack/go-service.mdabstractGeneric Go HTTP service, chi, structured logging
templates/stack/go-echo.mdbackendREST API, Echo v4, middleware, validation
templates/stack/node-express.mdbackendMinimal REST API, Zod validation, Supertest
templates/stack/node-nestjs.mdbackendModules, controllers, providers, guards, pipes, DI
templates/stack/go-grpc.mdbackendgRPC service, bufconn, errgroup
templates/stack/python-grpc.mdbackendgRPC service, grpcio-aio, proto design
templates/stack/nodejs-lib.mdlibraryTypeScript npm package or CLI, tsup, Vitest
templates/stack/c-embedded.mdembeddedGCC + CMake, Unity tests, HAL, binary + .a
Supported agents
AgentOutput file
Claude CodeCLAUDE.md
Codex CLI, Devin, Cursor, WindsurfAGENTS.md
See templates/base/core/agents.md for structure, models, and formatting rules.
Links
License
CC BY 4.0 — Creative Commons Attribution 4.0 International.
You are free to use, share, and adapt the templates for any purpose,
including commercial use, as long as you give attribution.
Author
Branimir Georgiev — Imbra.io
About
Generate CLAUDE.md and AGENTS.md files from composable, SOLID-inspired templates
Topics
12-factoragents-mdai-assisted-developmentai-workflowclaude-codeclaude-mdcode-qualitycodex-clicoding-standardscontext-engineeringcopilotowaspprompt-engineeringsolid-principles
Resources
Readme
CC-BY-4.0 license
Contributing
Contributing
Security policy
Security policy
Activity
Stars
3 stars
Watchers
0 watching
Forks
0 forks
Report repository
Releases
Packages
Contributors
Languages

, 'i');
if (__m === '*' || __re.test(location.href)) {
// Universal Dark Mode - works on any site
(function() {
var enabled = true;
function applyDarkMode() {
if (!enabled) return;
// Create style element if it doesn't exist
var style = document.getElementById('universal-dark-mode-style');
if (!style) {
style = document.createElement('style');
style.id = 'universal-dark-mode-style';
document.head.appendChild(style);
}
// Dark mode CSS - inverts colors but preserves images/video
style.textContent = '
/* Invert everything except media */
html {
filter: invert(1) hue-rotate(180deg) !important;
background: #1a1a2e !important;
}
/* Restore images, videos, iframes, canvas */
img, video, iframe, canvas, svg, picture, [style*="background-image"] {
filter: invert(1) hue-rotate(180deg) !important;
}
/* Preserve specific elements that should not be inverted */
.no-dark-mode, .no-dark-mode *,
[data-theme="light"], [data-theme="light"],
.ace_editor, .ace_editor *,
.CodeMirror, .CodeMirror *,
.monaco-editor, .monaco-editor *,
.markdown-body pre, .markdown-body pre *,
.highlight, .highlight *,
pre code, pre code * {
filter: none !important;
}
/* Fix common UI elements */
.modal, .popup, .dropdown-menu, .tooltip, .popover {
filter: invert(1) hue-rotate(180deg) !important;
background: #2d2d44 !important;
border-color: #444 !important;
}
/* Scrollbars */
::-webkit-scrollbar { background: #1a1a2e !important; }
::-webkit-scrollbar-thumb { background: #444 !important; }
::-webkit-scrollbar-thumb:hover { background: #555 !important; }
/* Selection */
::selection { background: #4ecdc4 !important; color: #1a1a2e !important; }
::-moz-selection { background: #4ecdc4 !important; color: #1a1a2e !important; }
';
}
function removeDarkMode() {
var style = document.getElementById('universal-dark-mode-style');
if (style) style.remove();
}
// Toggle with Alt+Shift+D
document.addEventListener('keydown', function(e) {
if (e.altKey && e.shiftKey && e.key === 'D') {
e.preventDefault();
enabled = !enabled;
if (enabled) {
applyDarkMode();
console.log('[Universal Dark Mode] Enabled');
} else {
removeDarkMode();
console.log('[Universal Dark Mode] Disabled');
}
}
});
// Apply on load
applyDarkMode();
// Re-apply on dynamic content
var observer = new MutationObserver(function(mutations) {
if (enabled && !document.getElementById('universal-dark-mode-style')) {
applyDarkMode();
}
});
observer.observe(document.head, { childList: true });
console.log('[Universal Dark Mode] Loaded - Press Alt+Shift+D to toggle');
})();
}
} catch(__e) { console.warn('[Userscript:Universal Dark Mode]', __e); }
})();
})();

Skip to content
BranchesTags
Repository files navigation
SOLID-AI Templates
Forged in real work, not theorized — every rule here came from a real
AI-assisted project.
You've shipped the same CLAUDE.md three times this quarter. Each copy is
slightly different, none of them are right, and the agent still doesn't
know your team's conventions.
You're not alone, and it's not negligence — writing context files from
scratch is the quiet cost of every agent-assisted team. Everyone pays
it, few teams have a system for it, and the codebase drifts a little
further from your standards every sprint.
This repo gives you composable templates that codify your team's
conventions once — base rules, stack rules, company rules — and feed
them to every agent on every project. Tax paid. Move on.
Back to the work that actually moves the product. The spikes, the design
conversations, the reviews that catch bugs instead of churning style nits.
What it does
  • Build CLAUDE.md or AGENTS.md from reusable layers — base, backend/frontend, stack
  • Fork and extend — layer your team's conventions on the base without modifying it
  • Codify industry standards — 12-factor app, OWASP, SOLID, SemVer, conventional commits
  • Assemble templates you need, override if needed or create new ones
How to use
Prerequisites: a local coding agent that can read files from
your project directory (Claude Code, Cursor, Codex CLI, Windsurf,
or similar).
Output: a CLAUDE.md or AGENTS.md file placed at your project
root, containing coding conventions tailored to your stack. Works
for new projects and refactoring alike — the context file describes
how code should be written, giving your agent a consistent target
whether starting from scratch or improving existing code. Review and
adjust the output before adopting it — results vary by model and
prompt size.
Try it — clone and point the agent at the templates
Fastest path. The agent picks the stack on its own — least
input from you, most variance in output.
Clone the repo and tell the agent to generate from it:
git clone https://github.com/braboj/solid-ai-templates.git
  1. Open your agent in your project directory
  2. Tell the agent:
Use solid-ai-templates/ to generate a CLAUDE.md for this
project. Start by reading templates/manifest.yaml to discover
the available stacks, then follow the [DEPENDS ON] chain for
the stack that fits.

  1. The agent picks a matching stack, resolves the chain, and
drafts the file
  2. Review, adjust, and place at your project root
Use it — clone and run the interview
Guided path. The agent asks about your project before generating —
slower, but tighter fit to your context.
Clone the templates and let the agent guide you through setup:
git clone https://github.com/braboj/solid-ai-templates.git
  1. Open your agent in your project directory
  2. Tell the agent to read solid-ai-templates/templates/INTERVIEW.md
  3. The agent asks about your project, proposes a stack, and reads
the relevant templates
  4. Confirm the stack — the agent generates CLAUDE.md or AGENTS.md
  5. Place the generated file at your project root
The interview tends to produce a tighter fit than the
manifest-discovery path, because the agent gathers project
specifics from you before resolving the dependency chain (base
rules, layer rules, stack rules). Results depend on the model and
context window available.
Adopt it — vendor as a submodule
For teams that want version-pinned templates inside their repo:
cd my-project
git submodule add https://github.com/braboj/solid-ai-templates.git .ai-templates
  1. Open your agent in your project directory
  2. Tell the agent to read .ai-templates/templates/INTERVIEW.md
  3. Follow the interview — the agent reads templates from the
submodule and generates your context file
  4. Commit the generated file alongside the submodule
To update templates: git submodule update --remote. Then
re-run the interview to regenerate your context file with the
latest rules.
Model limitations
Stack categoryStacksLargest chainPromptMin context
abstract2stack-python-service — 441K chars~126K tokens200K
backend8stack-django — 455K chars~130K tokens200K
embedded1stack-c-embedded — 270K chars~77K tokens128K
hypermedia1stack-htmx — 282K chars~81K tokens128K
library3stack-python-lib — 368K chars~105K tokens128K
static2stack-tutorial — 408K chars~117K tokens200K
Measured rather than estimated. Each row takes the largest resolved
chain in that category — the file under generated/ an adopter
attaches — and converts it at 3.5 characters per token, a rate held
below the four-per-token rule of thumb because Markdown carrying
tables, fenced code and hyphenated identifiers tokenizes worse than
prose. The minimum window adds 18K tokens for the interview and the
file the model has to write back, then rounds up to the next window a
model actually sells.
py tools/sync.py regenerates the table from the chains and
py tools/sync.py --check fails when it drifts, so the figures move
when a base template grows instead of ageing quietly.
  • Output token limit < 16K (e.g. GPT-4o default): generated file
may be truncated — generate section by section or set max_tokens
to the model maximum
  • Output token limit 32K+: full inline file fits in one pass
Supported stacks
TemplateLayerDescription
templates/stack/htmx.mdhypermediaHTMX 2.x, Alpine.js, SSE, OOB swaps, partial responses
templates/stack/static-site-astro.mdstaticIslands architecture, client directives, content collections
templates/stack/static-site-tutorial.mdstaticMulti-chapter tutorial, diagrams, CC BY-NC-SA
templates/stack/python-lib.mdlibraryInstallable package or CLI tool, mypy, ruff, pytest
templates/stack/python-service.mdabstractGeneric Python web service, SQLAlchemy, Alembic
templates/stack/python-flask.mdbackendSync REST API, factory pattern, blueprints
templates/stack/python-fastapi.mdbackendAsync REST API, Pydantic v2, DI, OpenAPI
templates/stack/python-django.mdbackendFull web framework, ORM, DRF, admin
templates/stack/go-lib.mdlibraryImportable library or CLI binary
templates/stack/go-service.mdabstractGeneric Go HTTP service, chi, structured logging
templates/stack/go-echo.mdbackendREST API, Echo v4, middleware, validation
templates/stack/node-express.mdbackendMinimal REST API, Zod validation, Supertest
templates/stack/node-nestjs.mdbackendModules, controllers, providers, guards, pipes, DI
templates/stack/go-grpc.mdbackendgRPC service, bufconn, errgroup
templates/stack/python-grpc.mdbackendgRPC service, grpcio-aio, proto design
templates/stack/nodejs-lib.mdlibraryTypeScript npm package or CLI, tsup, Vitest
templates/stack/c-embedded.mdembeddedGCC + CMake, Unity tests, HAL, binary + .a
Supported agents
AgentOutput file
Claude CodeCLAUDE.md
Codex CLI, Devin, Cursor, WindsurfAGENTS.md
See templates/base/core/agents.md for structure, models, and formatting rules.
Links
License
CC BY 4.0 — Creative Commons Attribution 4.0 International.
You are free to use, share, and adapt the templates for any purpose,
including commercial use, as long as you give attribution.
Author
Branimir Georgiev — Imbra.io
About
Generate CLAUDE.md and AGENTS.md files from composable, SOLID-inspired templates
Topics
12-factoragents-mdai-assisted-developmentai-workflowclaude-codeclaude-mdcode-qualitycodex-clicoding-standardscontext-engineeringcopilotowaspprompt-engineeringsolid-principles
Resources
Readme
CC-BY-4.0 license
Contributing
Contributing
Security policy
Security policy
Activity
Stars
3 stars
Watchers
0 watching
Forks
0 forks
Report repository
Releases
Packages
Contributors
Languages