Agentic

Agentic is a portable engineering system for AI-assisted software development: coding standards, project setup, requirements discovery, architecture and design review, implementation, testing, security audits, and production verification.

It brings together 17 reusable agent skills, standards and toolchains for Rust, Go, TypeScript, Python, Lua, Swift, and Kotlin, and installation paths for 12 coding harnesses. Use the standards in an existing repository, install individual skills, or follow the connected workflow from an idea through verified delivery.

What Agentic covers

Area	What it provides	Entry point
Engineering foundations	Universal coding rules, language-specific standards, architecture blueprints, formatter/linter configurations, and CI templates.	Language standards, universal rules
Project setup	Apply standards and agent instructions to a repository, preview changes, preserve existing files, and optionally add starter code.	`setup`, `agentic init`
Requirements and domain design	Clarify decisions and acceptance criteria, establish domain vocabulary and ADRs, and design module boundaries and interfaces.	`grilling`, `domain-modeling`, `codebase-design`
Architecture and design review	Explore alternatives, write specifications and implementation plans, run independent design critiques, and resolve findings through bounded review cycles.	`egm-brainstorm`, `egm-draft`, `egm-review`, `egm-review-loop`, `egm-resolve` — EGM workflows
Codebase documentation	Create source-grounded architecture documentation and report divergence between the code and its documented design.	`egm-bootstrap`, `egm-drift-report`
Implementation and delivery	Coordinate scoped implementation, independent QA, automated tests, live product checks, production readiness, bounded fixes, and authorized release.	`codinary`
Testing, debugging, and source review	Develop behavior tests, reproduce and diagnose failures, and review changes against both coding standards and the requested behavior.	`tdd`, `diagnosing-bugs`, `code-review`
Security	Focused security guidance or an explicitly requested six-phase audit with coverage records, independent validation, and structured findings.	`security-audit`
Conversational presentation	An optional terse voice that preserves technical facts, complete artifacts, and verification evidence.	`caveman`
Design handoffs and evidence	Validate approved-design artifacts, human signatures, source fingerprints, and review coverage before optional design-to-delivery intake.	`agentic handoff`, security model

The skill catalog explains individual commands. The architecture guide explains how their responsibilities connect.

Install in your coding harness

Choose one installation method for each harness.

Claude Code

Run inside Claude Code:

/plugin marketplace add igmrrf/agentic
/plugin install agentic@agentic

Then run /agentic:setup in your project.

Codex, OpenCode, and other harnesses

Run the matching command in your terminal. The installer needs Node.js 18+ and Bash (macOS, Linux, or Windows with WSL/Git Bash).

Harness	Install for all your projects
Codex	`npx -y github:igmrrf/agentic skills --global --agent codex`
OpenCode	`npx -y github:igmrrf/agentic skills --global --agent opencode`
Antigravity CLI (agy)	`agy plugin install https://github.com/igmrrf/agentic`
Antigravity App / IDE	`npx -y github:igmrrf/agentic skills --global --agent antigravity`
Gemini CLI	`npx -y github:igmrrf/agentic skills --global --agent gemini`
Cursor	`npx -y github:igmrrf/agentic skills --global --agent cursor`
GitHub Copilot	`npx -y github:igmrrf/agentic skills --global --agent copilot`
Cline	`npx -y github:igmrrf/agentic skills --global --agent cline`
Windsurf	`npx -y github:igmrrf/agentic skills --global --agent windsurf`
Amp	`npx -y github:igmrrf/agentic skills --global --agent amp`

Pi

pi install git:github.com/igmrrf/agentic

Reload your harness or start a new session after installation. In Codex, select $setup; in Pi, run /skill:setup. In other harnesses, ask: “Use the setup skill to apply Agentic standards to this project.”

Prefer a project install, selected skills, a Codex plugin marketplace, or a clone? See the installation guide, including updates, removal, and exact install locations.

Use it

For a focused feature or bug, start with Codinary and a concrete result. For uncertain requirements, use Grilling first. For complex architectural work, use EGM to develop and review a design before handing implementation to Codinary. Design and review skills can also be used independently.

Use codinary to add password reset. Tokens must expire after 30 minutes.
Use diagnosing-bugs to investigate this failing test.
Use code-review to review the changes since main.

Codinary owns implementation and delivery verification; EGM owns architecture and design documentation. A clean design review and human approval are separate. Small tasks can go directly to delivery, while approved-design intake uses the explicit handoff contract.

Claude plugin commands use /agentic:codinary. Codex skills use $codinary; Pi uses /skill:codinary. OpenCode loads skills through its skill tool when you name them in your request. The usage guide covers common workflows and harness differences.

Apply standards without installing skills

Run this from your project:

npx -y github:igmrrf/agentic init --lang=typescript --agent codex

Replace typescript with rust, go, python, lua, swift, kotlin, or all. Omit --agent to generate rules for all supported agents, including AGENTS.md. Existing files are preserved; add --dry-run to preview changes.

The initializer writes coding instructions, formatter/linter configurations, and GitHub Actions workflows. Add --no-ci to skip workflows, or --with-starter when you want starter code. See project setup for examples.

How the codebase fits together

Location	Responsibility
`CODING.md` and the seven language directories	Standards, architecture examples, language toolchains, and starter implementations.
`templates/`	Agent instruction templates and language-specific CI workflows.
`bin/` and `scripts/`	Project initialization, harness installation, registry generation, handoff commands, and packaging validation.
`skills/`	The 17 installable workflows, their references, scripts, and standalone resource bundles.
`framework/egm/`	Canonical design-review personas, rubrics, runtime adapters, and documentation templates.
`registry/`	Skill identities, dependencies, invocation policies, and metadata used to generate consistent installable packages.
`lib/`	Registry validation and the contracts and cryptographic checks behind approved-design handoffs.
`tests/`	Initializer characterization, installation lifecycle, packaging, integration, and handoff regression coverage. Additional validator and recovery tests live with their skills.
`docs/` and `licenses/`	Usage and technical guides, compatibility evidence, security boundaries, upstream provenance, and retained licenses.

Native plugins and packages expose the same canonical skills. Generated manifests, metadata, and self-contained bundles are checked for drift so selected-skill installs retain their required resources. See development and verification for the checks and release process.