Skip to content
tigusigalpaPublic

About

AI-KIT is a practical starter kit for development: ChatGPT/Codex, Claude, DeepSeek, KIMI, and other coding agents. It provides reusable project context, rules for each stack, adaptive model routing, conservative installation and updates, testing and review workflows, security guidance, Docker and Kubernetes readiness, and clean project templates.

Topics

Resources

Contributing

Security policy

Stars

29 stars

Watchers

1 watching

Forks

Latest commit

 

History

76 Commits

Folders and files

NameName
Last commit message
Last commit date
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 

Repository files navigation

AI-KIT

AI KIT

Stop re-explaining your project to every new AI chat.

AI-KIT gives your coding agents persistent project memory, expert stack rules, Kubernetes-ready container guidance, an adaptive model routing policy, and native entry files and configuration for 11 AI clients. Add Cloudflare security-audit for structured security review and Strix for scoped pentesting workflows. One offline installer, zero installer dependencies, changes previewed before you apply them.

Python 3.10+ PyPI version Dependencies: none AI clients: 11 Docker Hub License: MIT Docs site

What changed in each release: CHANGELOG.

v1.9.0: protect Astra, Fable, K3.1 or an exact model ID while keeping general recommendations enabled; add persistent exceptions quickly or preserve a model for one routing call. Release verification and publication status.

Published and verified: GitHub Release v1.9.0, Docker Hub tigusigalpa/ai-kit:1.9.0 and owner-approved PyPI ai-kit-python 1.9.0. Public hashes, immutable image pull and fresh Python installation passed. Verification receipts. Earlier artifacts remain intact.

Get AI-KIT · Update AI-KIT · Defaults · Features · Honest boundaries · Quick start · Docs site · Guides · Install guide · CLI flags · Windows · Docker

📘 Interactive documentation site

Build your install command in the browser instead of reading flag tables.

Pick your AI clients, preset, sharing mode, chat language and optional modules: the configurator writes the exact preview and apply commands for PowerShell or Bash and shows the resulting settings.json and file list. Every option is a real installer flag, and the commands are generated locally in your browser.

Open the documentation site

⚙️ Command configurator · 💻 Install the CLI · 🩺 After install · 📖 Flag reference · ❓ FAQ

English and Russian · light and dark themes · Windows PowerShell and Linux/macOS Bash

Get AI-KIT

Python package (recommended). Requires Python 3.10+; no mandatory third-party runtime dependencies.

pipx install ai-kit-python
aikit --version

The PyPI package is ai-kit-python; the command it installs is aikit. Never run pip install aikit: that is not this project's package name. Without pipx, run python -m pip install ai-kit-python inside a virtual environment. On Windows, the Windows guide covers PATH and interpreter problems.

Docker image. tigusigalpa/ai-kit runs the same CLI without host Python (linux/amd64). Image tags follow the repository VERSION of each release and there is no latest tag, so pick a version from the tags page, the verified version below is 1.9.0:

docker pull tigusigalpa/ai-kit:1.9.0
docker run --rm tigusigalpa/ai-kit:1.9.0 --version

Project mounts, preview/apply examples and the runtime contract are in Run AI-KIT with Docker.

Source checkout (alternative).

git clone https://github.com/tigusigalpa/ai-kit.git
cd ai-kit
python scripts/install.py --help

From a checkout, run python scripts/install.py or python aikit_cli.py COMMAND directly, or run python -m pip install . there to get the aikit command. Details: Get the CLI.

Update AI-KIT

Update the CLI first, then update the AI-KIT files in each project. These are separate operations:

What you update Command Result
Installed Python package / CLI python -m pip install --upgrade ai-kit-python Updates the installer available to that Python environment. Existing project files are unchanged.
AI-KIT inside the current project python -m aikit.aikit_cli install . --apply --check Uses that installer to update the current project's instructions and selected adapters, then checks the installation.

Check installation and version in the current folder

Open a terminal in the application's root folder and run this read-only, offline check (. means the current folder):

python -m aikit.aikit_cli doctor .

If aikit is available in PATH, the equivalent short command is aikit doctor .; use that form for a pipx installation. If Python reports No module named aikit, first install the CLI in the Python environment you are using.

The JSON report includes these fields (example excerpt):

{
  "installed_version": "1.5.0",
  "bundle_version": "1.9.0"
}
Field Meaning
installed_version The project's recorded AI-KIT baseline version, read from ai-kit/.install-state.json (accepted_version). Local edits or missing managed files are reported separately.
bundle_version The version bundled with the CLI you are running, used for the comparison and available for updating the project. The default check does not query PyPI; this field is not a claim about the newest published release.
errors Installation problems, such as missing/invalid installer state, invalid settings or missing managed files. Read these before treating the installation as healthy.
warnings / info Warnings and additional findings, including local changes and version comparisons.

In the example, the project records 1.5.0 while the CLI carries 1.9.0: preview and apply a project update using step 2 below. If the project version is newer than the CLI, update the Python package first (step 1). Matching versions still require reviewing errors and warnings for installation health. To show only the CLI version, run python -m aikit.aikit_cli --version.

If installation cannot be confirmed: installed_version stays null when the project version cannot be determined. Missing state produces No installer state found; is AI-KIT installed in this project?; invalid state produces an Invalid installer state error. This can mean AI-KIT was never initialized with the installer, was copied manually, or its state was lost or damaged. Review errors and the existing files before initializing or updating. Running doctor . without repair flags changes no project files.

1. Update the globally installed package

If you installed with pip, use the same Python environment as the existing installation. For a global installation, leave any project virtual environment first; if you intentionally installed AI-KIT in a virtual environment, activate that environment instead:

python -m pip install --upgrade ai-kit-python
python -m aikit.aikit_cli --version

The package name is ai-kit-python, not aikit. The module-based version check works even when aikit.exe is missing from PATH. If you installed with pipx, use this instead:

pipx upgrade ai-kit-python
aikit --version

These commands install the newest version published on PyPI; unreleased source changes become available there only after a release. They update the CLI without rewriting the AI-KIT files already installed in your application projects.

2. Update AI-KIT in the current project, preserving its settings

Open a terminal in your application's root folder, the folder containing its ai-kit/settings.json. In PowerShell, use Set-Location "C:\Projects\my-app" with your own path. . means the current folder, so check that you are in the intended project before continuing.

For a routine update, keep the saved language, clients, sharing mode, conventions and optional modules. Preview first, then apply the same update and run its installation health check:

python -m aikit.aikit_cli install .
python -m aikit.aikit_cli install . --apply --check

For a pipx installation, use aikit install . and then aikit install . --apply --check. Updating the CLI once does not automatically update every project; repeat this step in each project's root folder.

3. Full update example: Russian chat, Codex, Claude and Devin (Windsurf)

Use this example when you also want to set the listed options explicitly: Russian chat, all three clients, private sharing, strict client protections, maximum Docker cleanup and documentation/design/security workflows. It changes saved choices to match the flags; choose the options for your project before running it.

Preview (one line; works in PowerShell and POSIX shells):

python -m aikit.aikit_cli install . --chat-language Russian --agent codex --agent claude --agent devin --mode private --conventions owner --preset strict --docker-cleanup maximum --with-context7 --with-web-design --with-security-audit --with-strix --with-claude-github

Review writes, preserved, conflicts, adapter_conflicts and warnings. Then apply the same selection and check it:

python -m aikit.aikit_cli install . --chat-language Russian --agent codex --agent claude --agent devin --mode private --conventions owner --preset strict --docker-cleanup maximum --with-context7 --with-web-design --with-security-audit --with-strix --with-claude-github --apply --check

For pipx, replace the python -m aikit.aikit_cli prefix with aikit; keep the remaining arguments. Future routine updates can use the shorter commands in step 2 because these choices are saved.

Option in the example Meaning / how to adapt it
--chat-language Russian Russian chat replies and explanations; authored project files stay English. Use English for English replies.
--agent codex --agent claude --agent devin Select Codex, Claude Code and Devin (Windsurf). An explicit list replaces the saved client selection; include every client you want to keep. Remove --agent devin if unused; append other clients as repeated --agent NAME flags. Adapter retirement is separate from deselection.
--mode private Keep AI-KIT instructions/configuration local through ignore rules. Use team to share them in Git. Already tracked files are not automatically untracked.
--conventions owner Apply the owner's preferences only for confirmed stacks. Use standard to follow the existing project's conventions. Neither option enables UUID guidance by itself.
--preset strict Enable session-start, Git guards, destructive-action guards, native settings and scoped rules. These are instructions/client rules; verify their activation in the actual clients. CI remains a separate choice.
--docker-cleanup maximum Save the maximum post-task Docker cleanup policy, preserving persistent/unrelated data. The installer itself performs no Docker cleanup or host compaction. Use keep-cache to retain the dedicated project builder cache.
--with-context7 Add the documentation lookup skill. Register/authenticate its MCP server separately.
--with-web-design Add Web Design workflows and missing project design documents. Existing brief/design/acceptance documents are preserved; TypeUI setup is separate.
--with-security-audit --with-strix Add the optional security workflows and pinned reference resources. Installation starts no audit or scan; Strix runtime/model setup is separate.
--with-claude-github Add authenticated human GitHub identity checks before authorized Claude commits. Installation does not log in, change Git identity, commit or push.
--apply --check Write the update, then run the AI-KIT installation doctor. This checks installed kit files/configuration; application tests and audits are separate. Without --apply, even --check remains a preview.

Additional opt-ins: add --with-uuid to both commands only if you want public UUID guidance for the project's confirmed technology; it changes no application code or schema during installation. Add --with-orchestration if you want optional Codex helper configuration and disabled OpenRouter configuration; credentials, budgets and execution are separate. For a shared team installation, change --mode private to --mode team and optionally add --with-ci to install the workflow that checks committed AI-KIT files. Every flag and accepted value.

Preservation and conflicts: existing project documents and local adaptations follow the upgrade rules. Review and merge reported candidates before using --accept-local PATH for a reviewed managed file. A failed post-apply doctor check does not roll back files already written. Omitting an enabled module flag later does not disable that module; deselection and removal need the documented lifecycle. An ordinary update without --preset preserves the saved preset-managed choices as well.

For Docker, choose and pull an explicit new version tag and rerun the installer against the project mount; there is no latest image. Full update and conflict guide · Windows troubleshooting · Docker instructions.

Keep your chosen model and select instruction depth

Introduced in v1.8.0. Version 1.7.0 predates these controls. Install the new CLI/package/image and update your project; check the publication status before selecting a registry artifact. AI-KIT does not technically switch or lock the model of an ordinary Codex/Claude chat. It can influence instructions, offline advice and explicitly configured helper tasks.

Two independent keys in the project's ai-kit/settings.json control that influence:

Setting Values Default when absent Effect
model_switching_enabled JSON true / false true true retains existing conditional routing advice. false disables AI-KIT model/effort recommendations, including cheaper/weaker models for savings, and omits model/effort assignments in managed Codex helpers. It never changes the parent chat's settings.
instruction_profile "full" / "minimal" "full" full retains existing conditional instructions. minimal loads mandatory project and nested rules, architecture decisions, security, relevant stack rules and critical code-quality/check requirements, while skipping unsolicited upstream maintenance, optional workflows, extra roles and economic optimization.

For a difficult task on Astra with High or Extra High, select that model and effort yourself in the client, then use false + minimal to reduce optional AI-KIT guidance. Use false + full if you want the full project workflow while preserving your model choice. AI-KIT must not lower your effort, change other model settings, or suggest a weaker/cheaper model when recommendations are disabled. Availability and supported effort levels belong to the platform; see OpenAI's model/effort controls.

From the application project's current folder, preview then apply:

aikit install . --agent codex --agent claude --model-switching-enabled false --instruction-profile minimal
aikit install . --agent codex --agent claude --model-switching-enabled false --instruction-profile minimal --apply --check

Existing language, sharing mode, enabled extras and unrelated settings persist when omitted. Explicit --agent flags replace the selected client list; include all clients you want to keep. No client root configuration, model picker, reasoning effort, credentials or permissions are rewritten. A preview writes nothing; an apply with conflicts saves review candidates and leaves accepted files/settings unchanged. Reconcile local edits before claiming the new instructions are active. In particular, locally customized helpers are preserved as conflicts; unchanged managed helpers lose AI-KIT model/effort assignments when switching recommendations are disabled.

For manual configuration, merge these keys into the existing object, retaining other project settings:

{
  "model_switching_enabled": false,
  "instruction_profile": "minimal"
}

Then rerun aikit install . to preview the generated entry/helper changes, followed by aikit install . --apply --check. The keys are validated strictly: booleans are JSON booleans, not strings. Saved choices survive subsequent upgrades, presets and doctor --fix; missing keys preserve legacy behavior. After applying, start a fresh client session or reload project instructions through the client's supported mechanism. AI-KIT cannot remove instructions already loaded into a conversation.

Combination Behavior
true + full Existing conditional workflows and offline routing recommendations.
false + full Full project guidance with model/effort selection advice disabled.
true + minimal Mandatory task context; a directly requested routing command may still recommend a model. No unsolicited economic review or extra roles.
false + minimal Mandatory task context; no model/effort switching advice or generated helper overrides.

instruction_profile is separate from installer --preset minimal (an extras bundle) and router --profile economy|balanced|quality (an optimization policy). Setting one never silently changes the others. Minimal retains Git authorization, secrets/data protections, MCP consent, Docker safety, enabled UUID/human-identity requirements, owner conventions, architecture and acceptance checks. Relevant explicitly requested workflows remain available with their safety boundaries; stored optional files are not automatically loaded merely because they exist.

Inspect effective controls without running a model:

aikit doctor .
aikit context select . --path . --budget 32000
aikit route "Investigate the failing integration" --project .

Installer previews, doctor, context selection and routing expose instruction_settings. With recommendations disabled, route reports recommendations_enabled: false, model: null, effort: null and execution_confirmed: false; adaptive recommendations and metrics routing proposals are suppressed. Bare aikit route also honors settings in the current project folder. For another project, pass --project explicitly. Context selection retains mandatory/nested rules and architectural decisions even over the byte budget.

Doctor's runtime.model and runtime.reasoning_effort are null with status unavailable: an offline CLI cannot inspect the parent chat. Configured names, pins and helper defaults are not execution evidence. Inspect the client's actual model/effort display or platform telemetry when available. Existing aikit orchestrate status . receipts distinguish requested and provider-served models for those external calls; benchmark/metrics observations describe only their recorded execution. Missing effort telemetry stays unknown, and reasoning-token usage does not prove an effort setting.

Limitations: these are instruction/configuration controls, not a host-enforced lock. Native client defaults, global/project instructions, host routing, platform policy and previously loaded text remain outside AI-KIT's control. Disabling recommendations prevents new Aider native model settings; existing user/Aider configuration is preserved and doctor flags it for review. Codex helpers without overrides leave model/effort resolution to the host, including its own defaults. A separately enabled OpenRouter executor or explicit benchmark fixed model remains usable for an authorized task; it never silently replaces the parent model, and budget/accounting protections remain active. With switching disabled, the benchmark's adaptive arm retains the pack's explicit fixed route.

The architecture audit and control boundaries explain which paths AI-KIT actually controls. No speed, quality or token-saving improvement is claimed without a separate measured trial.

Conditional exceptions and quick model preservation

Introduced in v1.9.0. Update the CLI and project instructions first; check the publication status before selecting a registry artifact. Version 1.8.0 predates these exceptions. This extends the same settings mechanism, without a second router or a platform model-lock service.

Keep recommendations enabled for ordinary models while protecting your selected Astra, Fable or K3.1 model and reasoning effort:

aikit install . --agent codex --agent claude --model-switching-enabled true --model-switching-exceptions astra fable k3.1 --instruction-profile minimal
aikit install . --agent codex --agent claude --model-switching-enabled true --model-switching-exceptions astra fable k3.1 --instruction-profile minimal --apply --check

The protected list is saved in ai-kit/settings.json. Missing or empty means the previous behavior; existing installations do not opt in automatically. The setting is independent of full/minimal and presets. Merge this into the existing settings object if editing manually, then preview/apply the installer to reconcile managed helper files:

{
  "model_switching_enabled": true,
  "instruction_profile": "minimal",
  "model_switching_exceptions": ["astra", "fable", "k3.1"]
}
Condition Model/effort recommendations
Global model_switching_enabled: false Disabled, regardless of other choices.
A direct request to preserve a model for this task/call Preserve that choice; no automatic model change, effort change or cheaper-model handoff.
Exceptions enabled and selected model matches Preserve model and effort, including an explicitly chosen High/Extra High; never raise effort automatically either.
Exceptions enabled and current model unknown Suppressed until the user declares a choice; do not invent a model identity.
Current model does not match, or the list is empty Existing conditional recommendations remain available; required checks and explicit user preferences still apply.

The built-in names select families, accepting case-insensitive display names, version-shaped IDs and recognized provider prefixes. K3.1 Pro and its Highspeed variant are covered; K3 and K3.10 are not. Recognition is a protection preference, not proof that a model exists, is available to your account or actually ran. A custom entry matches an exact model name/ID case-insensitively; it does not protect unrelated names sharing a substring. Use the actual identifier from your client/provider when saving a custom entry.

Quick persistent exception for any model: append it without replacing the existing list, clients, language or extras:

aikit install . --protect-model "provider/custom-model-v1"
aikit install . --protect-model "provider/custom-model-v1" --apply --check

Replace the example with your model's actual name/ID. Repeat --protect-model to add several; adding an existing entry is idempotent. --model-switching-exceptions ... replaces the whole list; --model-switching-exceptions none --apply --check explicitly clears it. Global switching off still takes precedence after adding an exception.

One-call exception without saving anything:

aikit route "Investigate the regression" --project . --preserve-model "provider/custom-model-v1"

This suppresses AI-KIT routing advice for that invocation only and writes no settings or helper files. It reports reason: explicit_preservation, scope: invocation, the declared name and execution_verified: false. It does not start a model or control another chat. In a client conversation, an explicit instruction to preserve the selected model/effort applies to that task; start a fresh session after installing updated instructions.

For conditional offline advice, declare your current selection separately from the recommendation target:

aikit route "Investigate the regression" --project . --current-model Astra
aikit metrics propose . --stack PYTHON --task-class implement --level 2 --current-model Astra

--current-model declares user intent; it is not platform telemetry. A protected route reports recommendations_enabled: false, model: null, effort: null and reason: model_exception; a protected metrics proposal is refused. Null recommendation effort means no proposed override, not an API request to disable reasoning. --model remains the recommendation candidate and cannot silently bypass protection of --current-model. --current-model and --preserve-model are mutually exclusive. Doctor/context also show model_recommendation_policy; their offline current model remains unknown. Trusted platform metadata may guide an agent when available, but AI-KIT does not scrape global client settings, infer identity from quota usage or trust model self-identification.

Helpers: while any saved exceptions exist, all managed Codex helper files omit static model/effort assignments, including sessions on non-exempt models. Static files cannot conditionally follow a changing parent model. The parent must not pass conflicting overrides or automatically delegate to cheaper models for a protected task. A separately requested other-model task remains explicit and scoped. Unchanged managed helpers update normally; locally edited helpers conflict and require review. User root configuration is preserved. Existing Aider settings remain for review; configure writes no new static weak/work mapping with exceptions enabled.

A one-call flag cannot repair previously loaded or user-pinned helper definitions. For a protected task, use compatible inherited helpers; do not invoke conflicting fixed-model helpers. Report unavailable/unverified inheritance rather than claiming a lock. Persistent --protect-model ... --apply --check prepares managed helpers, followed by a client reload. Host-wide subagent defaults, platform routing and native client behavior remain outside AI-KIT enforcement.

An explicitly enabled OpenRouter text task retains its configured model and budget protections; exception guards suppress model-change advice without inserting effort parameters or automatic fallback. Benchmark adaptive arms use the pack's declared fixed model for exception checks; protected model/effort stay fixed, and changing exceptions prevents resuming the same incomparable experiment. Observed execution remains separate from declared settings.

Implementation, primary-source references and verification are tracked in the model controls audit.

Defaults you should know

Important

Chat replies and authored files default to English. Conventions default to the owner's Laravel preferences: no database foreign key constraints, Policy/Factory/Seeder per model and one table per migration. Public UUIDs are optional, enabled by --with-uuid for any confirmed technology.

For Russian replies and your project's own conventions, add both flags to the preview and the apply command:

aikit install /path/to/my-app --chat-language Russian --conventions standard

Other fresh defaults: private sharing mode, the codex client and maximum Docker cleanup. Existing projects retain their saved language and choices; update an existing language explicitly with --chat-language English. Claude installs suppress its added commit credit and preserve human authorship; --with-claude-github adds authenticated GitHub identity verification. All defaults · Owner profile

Features at a glance

Features at a glance

Feature What it does for you
🧠 Project memory Verified facts, module map, commands, and decisions that every new chat reads first
🧩 Stack profiles Expert rules for Go, PHP, Laravel, Filament 5, Moodle, Python, Rust, .NET, Java, Terraform/Helm, frontend, and libraries, auto-detected per module
🐳 Kubernetes-ready container guidance The kit instructs agents to make new Dockerfiles and services Kubernetes-ready: probes, graceful shutdown, non-root execution and manifests
🧭 Adaptive model routing A 0-6 capability ladder; the routing policy recommends a model role and reasoning effort per task. No savings are claimed
🤖 11 AI clients Native entry files and configuration for Codex, Claude Code, Cursor, Copilot, Gemini CLI, Devin (Windsurf), Cline, Roo, Aider, Kimi and Manus. The legacy windsurf adapter remains compatible. Documentation for Kimi and Manus is unverified, and activation in actual clients is unverified
🎯 Native client configuration Claude Code allow rules for the recorded test/lint/build commands (with --with-native-settings); module rules scoped to the paths where they apply (with --with-scoped-rules)
🛡️ Guardrails that reduce risk No commits without your request, optional ask rules before destructive commands, deny rules and ignore files for secret files. Not a security boundary
🔐 Optional security workflows Cloudflare's audit method and nine Strix skills, pinned and invoked explicitly in Codex or Claude Code
🎨 Optional Web Design Annotated references and a brief become a coherent visual system, stack-aware implementation and recorded UI acceptance; includes a dedicated Blade route
🔁 Engineering loop Plan → implement → test → review → document, with honest reporting of what was really checked
⚡ One-command workflows /ai-kit-bootstrap, /ai-kit-review, /ai-kit-sync-context
📦 Safe installer and upgrades Preview first, offline, backups, conflict candidates, explicit unchanged-adapter retirement, your local edits preserved
🐋 Docker CLI image Run the bundled installer and helpers without host Python; mount your project, preview changes and apply explicitly
🗂️ Shared dialogue context Import two conversations locally, review conflicting claims and export the same reference state for ChatGPT and OpenRouter

Why AI-KIT

Why AI-KIT

AI-KIT preserves facts and decisions, points agents at real checks and records authorization boundaries:

  • Project knowledge: manifests draft module facts and commands; bootstrap verifies them.
  • Stack depth: relevant profiles cover framework authorization, transactions, cancellation, privacy and infrastructure review.
  • Your authority: explicit commits/pushes, optional risky-command guards and secret exclusions.
  • Visible evidence: unavailable checks remain unverified.
flowchart LR
    A[aikit install preview] --> B[apply]
    B --> C["/ai-kit-bootstrap"]
    C --> D[plan → implement → test → review → document]
    D --> E["/ai-kit-sync-context"]
    E --> D
Loading

Feature tour

Project memory that survives every chat

  • Verified context: PROJECT_CONTEXT and project.json hold contracts, module facts, commands and unknowns.
  • Manifest drafts: Go, Composer, Node, Python and Moodle evidence suggests versions and module commands until bootstrap confirms them.
  • Session start: an optional Claude hook reads context and Git status.
  • Continuity: decisions, ADRs and changelog preserve reasons; the continuity skill keeps context and pointers synchronized.

What lands in your project

Built for your stack

Profile What the agent gets right
Go Context propagation, timeouts, error wrapping, goroutine ownership, -race, govulncheck, deliberate vendoring
PHP Composer and PSR boundaries, exact money, bounded HTTP, narrow exceptions, composer audit
Laravel Policies, bounded transactions, after-commit jobs, idempotent effects, N+1 checks, safe migrations
Filament 5 Resources, schemas, tables, and actions with server-side authorization, tenant scope, and bounded queries
Moodle Plugin APIs, capabilities and sesskey, upgrade savepoints, Privacy API, cache invalidation
Python Safe CLIs, pathlib, subprocess without a shell, isolated environments, uv/ruff for new packages
Frontend Pinned package manager, type/lint/build checks, accessibility, public-config hygiene
Library/SDK Public API stability, semantic versioning, consumer examples, compatibility matrices
Rust Ownership and borrowing, unsafe discipline, Result errors, cargo fmt/clippy/test, lockfile hygiene
JavaScript / TypeScript / Node.js Node services, CLIs, workers and packages; ESM/CommonJS, async cancellation, input validation, actual package scripts
.NET Nullable types, async with CancellationToken, deterministic disposal, dotnet build/test
Java Maven/Gradle wrappers, exception boundaries, try-with-resources, wrapper test/verify
Terraform/Helm Remote state, plan review, pinned providers and charts, fmt/validate and lint/template gates

Profiles combine per module, so a monorepo with a Laravel app in web/ and a Go service in api/ gets the right rules in each place. Opinionated owner conventions for Laravel (no database foreign keys, Policy + Factory + Seeder per model, one table per migration, Filament 5+ for new panels) are the default; use --conventions standard to follow your project's own conventions instead. Public UUID guidance is an independent opt-in; see optional UUIDs and Claude GitHub identity.

Docker-aware, Kubernetes-ready guidance

The kit instructs agents to make new Dockerfiles and services Kubernetes-ready, following the Kubernetes-ready contract, including local Docker Compose projects:

  • Images/runtime: pinned multi-stage images, build secrets outside layers, non-root execution, read-only root, exec entrypoints; no privileged mode or Docker socket.
  • Lifecycle: startup/readiness/liveness probes, SIGTERM drain, migrations in separate Jobs.
  • Deployment: ConfigMap/Secret, stdout logs, stateless replicas, PVCs where needed, dropped capabilities, seccomp and resource requests.
  • Preflight/cleanup: verify Docker client/daemon; after every Docker task remove eligible disposable containers, volumes, networks and superseded test images. The default maximum mode also removes the dedicated builder and its cache, without a size threshold, and reclaims host RAM/disk; --docker-cleanup keep-cache keeps the builder cache. Cleanup modes and host reclamation.

Adaptive model routing

The routing policy recommends a model role and reasoning effort for each task on a 0-6 capability ladder: the cheap role for classification and narrow mechanical edits, the work role for engineering and hard debugging, escalation after a diagnosed capability shortfall. Provider configurations map roles to OpenAI, Anthropic, Kimi, and Gemini models, or your own local/Ollama models. The offline helper understands English and Russian task descriptions and explains its choice:

aikit route "debug a race condition in the queue worker"

It is a recommendation, and no cost savings are claimed. The kit never fakes a model switch: when a client offers no switching control, you get a recommendation. Levels, providers and configuration.

Works with your AI clients

Client What gets installed
Codex AGENTS.md and .agents/skills/
Claude Code CLAUDE.md importing AGENTS, skills, settings, path-scoped .claude/rules/
Cursor .cursor/rules/ with module globs, .cursorignore secrets
GitHub Copilot copilot-instructions.md and per-module .instructions.md
Gemini CLI GEMINI.md and .geminiignore; reads the shared skills
Devin (Windsurf) --agent devin: .devin/rules/ai-kit.md and optional module rules; --agent windsurf retains the legacy .windsurf/rules/ adapter
Cline, Roo Native rule folders, with path-scoped module rules for Cline
Aider CONVENTIONS.md and .aiderignore, plus model routing config
Kimi, Manus Short entry files

Scoped rules, ignore files, and settings come with the native-settings and scoped-rules extras. The preview spots the clients you already use from existing files and suggests the matching --agent list. Copying files does not prove that a client discovers or activates them, and documentation for Kimi and Manus is unverified; aikit adapters report --project TARGET lists each client's documentation status.

For a new Codex + Claude + Devin (Windsurf) setup, run this from the application directory:

python -m aikit.aikit_cli install . --agent codex --agent claude --agent devin --mode private --preset strict --with-security-audit --with-strix --with-context7 --with-web-design --with-claude-github --apply --check

Add --with-uuid only if the project should adopt public UUID guidance. Explicit --agent flags describe the complete selection; include every client you want to keep. To move an existing installation from windsurf to devin, temporarily include both adapters in the full selection and preview/apply it. Then preview aikit adapters retire . --agent windsurf and repeat with --apply after review; the retirement removes only unchanged owned legacy rules and deselects windsurf. Edited legacy rules remain conflicts and are preserved. Devin loads both rule directories, so inspect overlapping rules before using it. The supported current paths and legacy imports are documented in Devin Local customizations; --agent devin targets the local/desktop rule format.

Optional UUIDs and Claude GitHub identity

Option Default Effect
--with-uuid Off; independent of presets and owner/standard Installs public UUID guidance, saves uuid=true, and adds a short AGENTS entry for any confirmed language or technology. No code, columns, primary keys or routes are changed by installation.
--with-claude-github Off; independent of presets Installs Claude GitHub identity guidance, saves claude_github=true, and links it from the selected Claude entry. Before an authorized commit, Claude verifies the active account for the repository's GitHub host and matches human author/committer details. Missing or conflicting identity stops that commit for clarification.

All Claude installations include the baseline human-authorship rule and request attribution.commit as an empty string in their managed local/team settings. This suppresses Claude's commit-credit trailer; it does not change Git's author fields. Existing custom attribution values produce a reviewable conflict instead of being overwritten. Existing human co-authors, signing and PR-attribution preferences are preserved. Claude attribution reference.

Example: add both policies to an existing project while preserving its saved client selection:

python -m aikit.aikit_cli install . --with-uuid --with-claude-github
python -m aikit.aikit_cli install . --with-uuid --with-claude-github --apply --check

The GitHub policy needs Claude selected; add --agent claude alongside the full desired client list when necessary. Nothing logs in, queries GitHub, changes global Git settings, commits or pushes during installation. These flags persist across upgrades. Omitting them later does not disable them; review and set uuid or claude_github to false in ai-kit/settings.json to deselect. Existing files/data remain preserved. Changing a setting never authorizes destructive schema changes or a Git operation.

Connect TypeUI to Codex and Claude

TypeUI supplies design guidance; the coding client implements it in your project. AI-KIT supplies the brief, project memory and acceptance workflow. Adding --with-web-design installs those local resources; registering and authenticating the TypeUI MCP server is a separate step. The commands below configure the clients you run them in, rather than the AI-KIT Docker container. The hosted service is not bundled or revision-pinned by AI-KIT.

1. Prepare the application

Open a terminal in the application directory. Install/update AI-KIT, selecting the full client list you use; preview first by omitting --apply --check:

python -m aikit.aikit_cli install . --agent codex --agent claude --with-web-design --apply --check

Keep an already-selected --agent devin or other client in that list if needed. Fill docs/design/BRIEF.md with the goal, audience, required pages/sections, content, reference URLs, assets, supported screen sizes and constraints. Put the approved visual direction in docs/design/SYSTEM.md and measurable checks in docs/design/ACCEPTANCE.md. Existing documents are preserved; review actual frameworks and versions before asking for implementation.

2. Connect Codex

Check that the Codex CLI is available with codex --version, then register the official HTTP endpoint:

codex mcp add typeui --url https://mcp.typeui.sh/mcp
codex mcp list
codex mcp login typeui

Complete the sign-in in the browser yourself. Start/reopen Codex and use /mcp in its terminal interface to inspect the active connection. In an IDE extension, inspect MCP servers and restart the extension after configuration changes. Listing a server proves registration; a successful authenticated tool call proves the current connection. TypeUI's Codex guide · OpenAI MCP configuration and authentication.

For project-scoped configuration, merge this table into the existing .codex/config.toml instead of replacing the file or creating a duplicate table:

[mcp_servers.typeui]
url = "https://mcp.typeui.sh/mcp"

Keep credentials out of that file and the repository; the client handles sign-in separately. Check which configuration is effective in the client you actually use. A remote/web session does not inherit a local process's configuration automatically.

3. Connect Claude Code

From the same application directory, check claude --version and add the HTTP connection at the private, current-project scope:

claude mcp add --transport http --scope local typeui https://mcp.typeui.sh/mcp
claude mcp list
claude

Inside Claude Code, enter /mcp, choose typeui, authenticate and finish the TypeUI sign-in. The local scope is stored under the project's entry in your personal ~/.claude.json. For a team-shared endpoint use --scope project instead; Claude writes .mcp.json, and each teammate authenticates separately. Review an existing registration before adding another with the same name. TypeUI's Claude guide · Claude MCP scopes.

This example targets Claude Code. A Claude chat/desktop connector has its own setup; registering a CLI connection does not automatically configure every Claude application.

4. Verify access and prepare the design context

Ask the client to inspect available TypeUI tools and check sign-in/access before generation. For the currently exposed tools, typeui_check_access and typeui_get_usage provide the access/usage checks. An account or plan requirement must be resolved in TypeUI; AI-KIT does not supply access or promise a free quota.

For a custom visual system, create or import a draft in TypeUI, review its Markdown, then publish it for MCP. Choose one visual system for the task. Keep AI-KIT's engineering/acceptance rules and reconcile conflicting visual instructions before generating. Follow TypeUI's MCP workflow for the current account and publishing steps.

5. Run a bounded design task

In Codex use $web-design; in Claude Code use /web-design. Supply a concrete request such as:

Use the web-design workflow and the connected TypeUI tools.
Read docs/design/BRIEF.md, SYSTEM.md and ACCEPTANCE.md first.
Confirm the actual framework and package versions. Reuse the existing application.
Check TypeUI access, then prepare one approved visual direction.
Propose the page structure and implement the hero section first.
Review responsive behavior, keyboard access and real browser output.
Continue after that section meets the acceptance criteria.
Do not deploy or replace the project's tooling without an explicit request.

Treat generated prompts as design inputs under the project's instructions. Review any returned skill-install command before executing it; choose a project-local location and inspect existing files. For a multi-section TypeUI workflow, complete the requested cleanup/acceptance for the current section before asking for the next one. Record only reviewed decisions in the design documents. A generated layout still needs the project's actual build/tests and browser review.

Troubleshooting TypeUI

Symptom Check and resolution
codex or claude is not recognized Install/repair that client's CLI and PATH using its own documentation. python -m aikit.aikit_cli starts AI-KIT, not either coding client.
Server is listed but no tools are available Inspect /mcp, verify the configured endpoint, authenticate, then restart/reconnect the client. Check whether it is using user, project, or another environment's configuration.
Browser login fails or the server returns 401/403 Reauthenticate through the client, verify the intended TypeUI account and current access, and inspect organization/network restrictions. Keep credentials out of chat and Git.
aikit mcp report . does not show a registered server The report inventories project files only. Codex user configuration and Claude's local-scope registration are outside that report; use their native connection status.
TypeUI works in Codex but not Claude Each client has a separate MCP registration and sign-in; complete both setup paths.
Output disagrees with the brief or changes framework Reconcile the brief, the selected visual system and the actual stack; rerun one bounded section with explicit constraints. Review changes before continuing.

These instructions are source-checked setup guidance. Live authentication and generated-site acceptance must be verified in the target clients.

Native configuration from your project facts

  • Recorded checks: Claude Code allow rules for the recorded test/lint/build commands (with --with-native-settings).
  • Secret exclusions: shared lists cover env files, keys, Composer auth, Laravel/Moodle credentials and .pypirc through selected client deny/ignore controls.
  • Module scope: native rules select relevant guidance by file path (with --with-scoped-rules).
  • Owned entries: Claude settings merge by key, using local settings in private mode and moving only kit entries on mode switches.

Guardrails that reduce risk

These guardrails reduce risk through instructions, client ask/deny rules and ignore files. They are not a security boundary or a sandbox.

  • No surprise commits. Commits and pushes require your explicit request, and optional Claude Code ask rules back that up.
  • Confirmation before damage. With data guards, Claude Code asks before rm -rf, git reset --hard, git clean, a Docker prune, or a Laravel/Moodle migration.
  • Secret files. Deny rules and ignore files discourage reads of common secret files in clients that honor them; they do not encrypt or lock those files.
  • Security baseline: input validation, server-side authorization, and no secrets in code, logs, or prompts. Dependency audits run per stack with composer audit, govulncheck, pip-audit, and your package manager's audit.
  • Honest verification: unavailable tools, services, or CI are reported as unverified, never as passed.

Engineering loop and one-command workflows

Every task follows plan → implement → test → review → document, with staged migrations and rollback plans, review by concrete scenario and severity, and a changelog entry for every change. Owner conventions add a Codecov gate of at least 90% of changed lines when Codecov is configured. Three user-invoked skills make the routine instant:

  • /ai-kit-bootstrap confirms installer drafts and fills context from real evidence.
  • /ai-kit-review reviews current changes against the engineering and security rules.
  • /ai-kit-sync-context updates context, decisions, and the changelog after work.

In Codex, use $ai-kit-bootstrap and the other skills the same way.

Security workflows

Integration What it adds Install flag Codex / Claude Code
Cloudflare security-audit Security guidance and focused review; a full audit method with reconnaissance, hunting, evidence validation, coverage and reporting --with-security-audit $security-audit / /security-audit
Strix Workflows for code, web application, API and OWASP testing, findings review and requested remediation; separate CI/cloud references --with-strix $strix / /strix

Both are off by default, pinned to reviewed upstream revisions and invoked explicitly. Installation copies files only: it runs no audit or scan, and a Strix scan needs its own CLI, Docker, model access and authorized targets. Security workflows guide.

Web Design

Give your agent the sites you like, a short brief and the target project. The optional module (--with-web-design) organizes that material into one visual direction, reusable components and a working interface with recorded checks, with a detailed Laravel/Blade route and conditional guidance for Tailwind, Bootstrap, Alpine, Livewire, daisyUI, Flowbite and Flux. It installs no external tools and generates or deploys nothing by itself. Web Design guide: implementation routes · tools, review and troubleshooting.

Library documentation with Context7

The optional context7-docs workflow (--with-context7) checks the dependency version, resolves the library, retrieves focused examples and records source/coverage gaps. MCP connection and authentication stay separate. Context7 guide.

Shared context from two dialogues

The offline aikit memory command imports two conversations, preserves their sources, shows contradictions for your review and exports the same reviewed reference state as ChatGPT Markdown and an OpenRouter request fragment. It uploads nothing and needs no API key. Dialogue context guide.

Optional orchestration

--with-orchestration adds scoped Codex helper agents and a disabled-by-default, bounded OpenRouter text executor with explicit apply, capped-key preflight, private accounting and review. Installation launches no agents and makes no paid calls. Orchestration guide.

Optional task workflow: requirements, states and checks tied to code

Introduced in v1.7.0. Upgrade the CLI and update each project using the normal update procedure, then explicitly enable this extra. Version 1.6.0 does not contain these commands. Check the release status before selecting a registry artifact; PyPI availability follows the owner's approval. A wheel built from this checkout is also supported.

Enable the module from your application's root folder. Omitting client flags preserves its saved clients and other settings:

python -m aikit.aikit_cli install . --with-task-workflow
python -m aikit.aikit_cli install . --with-task-workflow --apply --check

The flag saves task_workflow=true, installs the short ai-kit/TASK-WORKFLOW.md contract and creates ai-kit/task.example.json only if missing. It is off by default and independent of presets. No agent or check is launched during installation. The project-owned example and task history survive upgrades.

Describe the task before implementing it

Edit the installed example with a bounded objective, constraints/non-goals, concrete acceptance criteria and verified commands for this project. Its Python command is illustrative: for a Laravel application, use the actual PHP/Pest/PHPUnit command and environment established by that project. For example:

{
  "schema": 1,
  "id": "catalog-filter",
  "title": "Add a category filter to the catalog",
  "description": "Filter by an existing category while retaining pagination. Preserve the public response format. Do not change authentication, database schema or unrelated pages.",
  "acceptance": [
    {"id": "filter", "description": "Selecting a category returns only matching items."},
    {"id": "compatibility", "description": "Requests without a filter retain the existing response and pagination behavior."}
  ],
  "checks": [
    {"id": "feature-tests", "argv": ["php", "artisan", "test", "--filter=CatalogFilterTest"], "cwd": ".", "timeout_seconds": 300}
  ]
}

The test name is an example to replace, not a test AI-KIT creates. argv is an argument array, not a shell command string. Each criterion/check has a distinct lowercase ID. Every declared check is required. Tasks and criteria describe the requested outcome; the commands run with your current local permissions/environment. Review their data/service access before execution.

Save your definition in ai-kit/task.example.json or another reviewed JSON file, then preview and create it:

python -m aikit.aikit_cli task create . --from-json ai-kit/task.example.json
python -m aikit.aikit_cli task create . --from-json ai-kit/task.example.json --apply
python -m aikit.aikit_cli task transition . --task-id catalog-filter --to implementing --apply

An identical repeated create preserves the existing state. Changed requirements need task revise . --from-json FILE --apply: the same task ID receives a new revision, returns to planned and requires another implementation/check cycle. Historical receipts and approvals are retained.

Run and inspect checks explicitly

After implementing the change, preview the exact declared command and execute it separately:

python -m aikit.aikit_cli task check . --task-id catalog-filter --check-id feature-tests
python -m aikit.aikit_cli task check . --task-id catalog-filter --check-id feature-tests --apply
python -m aikit.aikit_cli task status . --task-id catalog-filter

Checks require the Git working-tree root. A fingerprint covers the task revision/cycle, Git HEAD and index, actual tracked file contents/deletions, and nonignored untracked files. A check is tied to that fingerprint before and after execution. New source edits, staging, commits or changed requirements invalidate earlier evidence. Ignored generated output does not invalidate it; ignored dependencies, databases, services, environment and tool versions are outside the fingerprint and need separate review. Source must remain quiescent during observation.

Receipts retain the command, timestamps, return code, duration, output hash/byte count and fingerprint. Raw child output is discarded, so inspect a failed check with the project's normal test command when necessary. A nonzero exit, timeout, interruption or observed source change cannot be accepted as a pass. If a check changes source, review that change, return to implementing, then rerun the required checks. Checks execute locally; AI-KIT does not provide a process/network sandbox or provision a test environment.

Review and accept the exact checked version

The normal path is:

planned -> implementing -> checking -> reviewing -> awaiting_approval -> accepted

task check --apply enters checking; all required checks must have current passing receipts before these next transitions are allowed:

python -m aikit.aikit_cli task transition . --task-id catalog-filter --to reviewing --apply
python -m aikit.aikit_cli task transition . --task-id catalog-filter --to awaiting_approval --apply
python -m aikit.aikit_cli task status . --task-id catalog-filter

Review the actual behavior against each criterion. Copy the current fingerprint from status into a review JSON file and supply evidence for every criterion. Keep that review file outside source discovery: for example, create ai-kit/.tasks/reviews/ and save this as catalog-filter.json there. A review file included in the source fingerprint would itself change the version being reviewed.

{
  "schema": 1,
  "task_id": "catalog-filter",
  "fingerprint": "REPLACE_WITH_THE_64_CHARACTER_FINGERPRINT_FROM_STATUS",
  "reviewer": "REPLACE_WITH_THE_ACTUAL_REVIEWER",
  "criteria": [
    {"id": "filter", "passed": true, "evidence": "REPLACE_WITH_THE_OBSERVED_FILTER_RESULT"},
    {"id": "compatibility", "passed": true, "evidence": "REPLACE_WITH_THE_OBSERVED_COMPATIBILITY_RESULT"}
  ]
}
python -m aikit.aikit_cli task accept . --task-id catalog-filter --from-json ai-kit/.tasks/reviews/catalog-filter.json
python -m aikit.aikit_cli task accept . --task-id catalog-filter --from-json ai-kit/.tasks/reviews/catalog-filter.json --apply

Acceptance requires the current fingerprint, every declared criterion and all current successful checks. It records the reviewer's local assertion; it does not authenticate identity or independently prove correctness. It grants no commit, push, release or deployment authorization. If source changes afterward, status reports effective_state: stale and accepted_current: false; the historical acceptance remains visible.

Situation What to do
Continue implementation after review/failure or reopen an accepted task Explicitly transition to implementing. This starts a new cycle and requires fresh checks.
Mark work unsuccessful Use --to failed from an active state; preserve the receipts and findings.
Cancel an active task Use --to cancelled. Cancellation is terminal and changes task state; stop/wait for any running check first. It does not undo code or control other processes.
Interrupted check or stale lock Confirm the recorded lock owner has stopped before removing only ai-kit/.tasks/write.lock. Return the task to implementing; pending receipts become interrupted history.
Unsupported transition or missing/stale check The operation refuses. Review status and follow the declared state path.
Symlink/junction, submodule, unresolved merge, case collision or nonignored credential file Source inspection refuses; resolve the boundary/visibility issue before checking.

All mutations preview without --apply; status is read-only. Exit code 0 means the requested operation succeeded, 1 means an executed check did not pass, and 2 means invalid input/state or a refused operation. Definitions, events, receipts and approvals stay in private ai-kit/.tasks/ in both sharing modes and are excluded from wheel/image build inputs. Set task_workflow=false to disable the CLI without deleting its history. Automatic agent coordination, scheduling, model calls and hosted-CI import are separate work. Technical contract and verification.

Working with OpenRouter

AI-KIT rules, project facts and selected context can travel with your API requests; the guide covers request layout, prompt and response caching, and measuring actual usage. OpenRouter guide.

Run AI-KIT with Docker

The tigusigalpa/ai-kit image runs the installer and helpers with a read-only root, no network and an explicit project mount: preview with a read-only mount, then apply with a writable one. Docker guide.

Measure, recommend and select context

aikit benchmark runs isolated A/B/C trials through a reviewed worker, aikit route --mode adaptive recommends from comparable history, and aikit context select selects module rules within a byte budget. Measurement guide.

More built in

  • Language/sharing: English files and chat by default; saved project languages remain unchanged on upgrades. Private or team instructions. Sharing.
  • Health: aikit doctor TARGET reports managed-file, link, provider and context drift and names the upgrade commands when a newer AI-KIT is available; --fix previews a repair plan and --fix --apply writes it, preserving local edits. An older CLI refuses to downgrade a newer installation unless you pass --allow-downgrade.
  • MCP review: aikit mcp report TARGET lists MCP servers from project client files with transports, commands and variable names, never secret values, and warns about literal credentials, plain remote HTTP and auto-approval. Details.
  • CI: --with-ci adds a workflow that validates the committed AI-KIT files; it does not clone or install AI-KIT and is meaningful in team mode.
  • Measurements: aikit metrics records supplied attempt/token/cost evidence and analyzes provider results. No automatic telemetry; evaluation checks opaque pair coverage.

Honest boundaries

Honest boundaries

  • Installation copies files. It runs no audit, scan, model call, cleanup or external tool setup; optional modules need their own tools, credentials and authorization.
  • Client activation is unverified. AI-KIT writes native entry files and configuration; whether a client discovers and applies them must be checked in that client. Documentation for Kimi and Manus is unverified.
  • Routing recommends. Confirm actual client controls; no cost savings are claimed.
  • Guardrails reduce risk. Permission rules and ignores are not a security boundary.
  • Measurement needs evidence. The benchmark requires its own reviewed protocol worker. Optional OpenRouter text execution is separately enabled and explicitly applied; native client activation and end-to-end savings require independent verification.
  • CI checks files, not behavior. The --with-ci workflow validates committed AI-KIT files only; it does not run your application's tests.

Install

Quick start in three steps.

Install

Use an application folder outside any AI-KIT checkout.

1. Preview. Nothing is written:

aikit install /path/to/my-app --preset solo --agent codex --agent claude

On Windows use a path like "C:\Projects\my-app". The preview lists writes, preserved files, conflicts, and detected stacks/clients. Add --chat-language English --conventions standard here and in step 2 to change the defaults.

2. Apply the same command with --apply; add --check to run the doctor right away:

aikit install /path/to/my-app --preset solo --agent codex --agent claude --apply --check

3. Bootstrap. Open your AI client in the project and run /ai-kit-bootstrap (Claude Code) or $ai-kit-bootstrap (Codex). For other clients, give it BOOTSTRAP_PROMPT.md.

Existing project documents and context are never overwritten; customized instructions become reviewable conflicts. From a source checkout, python scripts/install.py takes the same arguments; in Docker, see preview and apply.

Documentation

Teach any AI about AI-KIT

Teach any AI about AI-KIT

The repository is a skill: SKILL.md covers installation, configuration, upgrades and maintenance. For Claude Code, clone into your skills directory:

git clone https://github.com/tigusigalpa/ai-kit.git ~/.claude/skills/ai-kit

For other assistants, share the repository or SKILL.md.

For maintainers

Applications install from template/; the root maintains AI-KIT itself. Before contributing, run:

python scripts/check_kit.py
python -m unittest discover -s tests -v

See CONTRIBUTING.md and the maintainer guide for local maintainer files, publication copy and the PyPI release procedure.

License

AI-KIT is released under MIT; bundled Cloudflare references retain MIT and Strix references retain Apache-2.0. Choose and verify your application's license separately.

About

AI-KIT is a practical starter kit for development: ChatGPT/Codex, Claude, DeepSeek, KIMI, and other coding agents. It provides reusable project context, rules for each stack, adaptive model routing, conservative installation and updates, testing and review workflows, security guidance, Docker and Kubernetes readiness, and clean project templates.

Topics

Resources

Contributing

Security policy

Stars

29 stars

Watchers

1 watching

Forks

Releases

Contributors

Languages