Version 2.6.0 released!

Your Code Reviews Just Got 12 Expert Opinions. In 30 Seconds.

Here's what happened when we shipped yesterday: security audit, performance analysis, architectural review, pattern detection, and eight more specialized checks—all running in parallel. No meetings. No waiting. Just answers. That's Antigravity Cortex: 27 specialized skills, 19 workflows, and 12 utility skills that make today's work easier than yesterday's.

Install Plugin Read the Docs

Agent Skills

Workflows

Utility Skills

MCP Servers

Why Your Third Code Review Should Be Easier Than Your First

Think about the last time you fixed a Rails N+1 query. You found it. You fixed it. Then next month, different developer, same bug, same investigation. That's linear engineering—you solved it, but the solution evaporated.

"Most engineering work is amnesia. You solve a problem on Tuesday, forget the solution by Friday, and re-solve it next quarter. Compounding engineering is different: each solved problem teaches the system. The security review you run today makes tomorrow's review smarter. The pattern you codify this sprint prevents bugs in the next three."

Plan

Stop starting over from scratch

You know that moment when you open a ticket and think "how did we solve this last time?" The framework-docs-researcher already knows. The git-history-analyzer remembers what worked in March. Run /plan and three research agents work in parallel—one reading docs, one analyzing your repo's history, one finding community patterns. In 60 seconds, you have a plan built on institutional memory instead of starting cold.

framework-docs-researcher best-practices-researcher repo-research-analyst git-history-analyzer

Delegate

Work with experts who never forget

The security-sentinel has checked 10,000 PRs for SQL injection. The kieran-rails-reviewer never approves a controller with business logic. They don't get tired, don't skip Friday afternoon reviews, don't forget the conventions you agreed on in March. Run /work and watch your plan execute with quality gates that actually enforce your standards—every single time.

27 specialized agents /work dhh-rails-style skill git-worktree skill

Assess

Get twelve opinions without twelve meetings

Type /review PR#123 and go get coffee. When you come back, you'll have a security audit (did you sanitize that user input?), performance analysis (N+1 spotted on line 47), architecture review (this breaks the pattern from v2.3), data integrity check (that migration will fail in production), and eight more specialized reviews. All running in parallel. All categorized by severity. All stored as actionable P1/P2/P3 todos you can knock out in order.

security-sentinel performance-oracle architecture-strategist data-integrity-guardian

Compound

Make sure you never solve the same bug twice

Remember that CORS issue you debugged for three hours last month? Neither do I. That's the problem. Run /compound right after you fix something and it captures the solution as searchable documentation with YAML frontmatter. Next time someone hits the same issue, they grep for "CORS production" and find your answer in five seconds instead of re-debugging for three hours. That's how you compound.

/compound compound-docs skill file-todos skill

27 Specialized Agent Skills

Think of them as coworkers who never quit. The security-sentinel has seen every SQL injection variant. The kieran-rails-reviewer enforces conventions with zero compromise. The performance-oracle spots N+1 queries while you're still reading the PR. Run them solo or launch twelve in parallel—your choice.

Review Agents (11)

kieran-rails-reviewer Rails

Super senior Rails developer with impeccable taste. Applies strict conventions for Turbo Streams, namespacing, and the "duplication over complexity" philosophy.

skill: kieran-rails-reviewer

dhh-rails-reviewer Rails

Reviews code from DHH's perspective. Focus on Rails conventions, simplicity, and avoiding over-engineering.

skill: dhh-rails-reviewer

kieran-python-reviewer Python

Python code review with strict conventions. PEP 8 compliance, type hints, and Pythonic patterns.

skill: kieran-python-reviewer

kieran-typescript-reviewer TypeScript

TypeScript review with focus on type safety, modern patterns, and clean architecture.

skill: kieran-typescript-reviewer

security-sentinel Security

Security audits and vulnerability assessments. OWASP top 10, injection attacks, authentication flaws.

skill: security-sentinel

performance-oracle Performance

Performance analysis and optimization recommendations. N+1 queries, caching strategies, bottleneck identification.

skill: performance-oracle

architecture-strategist Architecture

Analyze architectural decisions, compliance, and system design patterns.

skill: architecture-strategist

data-integrity-guardian Data

Database migrations and data integrity review. Schema changes, foreign keys, data consistency.

skill: data-integrity-guardian

pattern-recognition-specialist Patterns

Analyze code for patterns and anti-patterns. Design patterns, code smells, refactoring opportunities.

skill: pattern-recognition-specialist

code-simplicity-reviewer Quality

Final pass for simplicity and minimalism. Remove unnecessary complexity, improve readability.

skill: code-simplicity-reviewer

julik-frontend-races-reviewer JavaScript

Review JavaScript and Stimulus code for race conditions, DOM event handling, promise management, and timer cleanup.

skill: julik-frontend-races-reviewer

Research Agents (4)

framework-docs-researcher Research

Research framework documentation and best practices. Find official guidance and community patterns.

skill: framework-docs-researcher

best-practices-researcher Research

Gather external best practices and examples from the community and industry standards.

skill: best-practices-researcher

git-history-analyzer Git

Analyze git history and code evolution. Understand how code has changed and why.

skill: git-history-analyzer

repo-research-analyst Research

Research repository structure and conventions. Understand project patterns and organization.

skill: repo-research-analyst

Design Agents (3)

design-iterator Design

Iteratively refine UI through systematic design iterations with screenshots and feedback loops.

skill: design-iterator

figma-design-sync Figma

Synchronize web implementations with Figma designs. Pixel-perfect matching.

skill: figma-design-sync

design-implementation-reviewer Review

Verify UI implementations match Figma designs. Catch visual regressions.

skill: design-implementation-reviewer

Workflow Agents (5)

bug-reproduction-validator Bugs

Systematically reproduce and validate bug reports. Create minimal reproduction cases.

skill: bug-reproduction-validator

pr-comment-resolver PR

Address PR comments and implement fixes. Batch process review feedback.

skill: pr-comment-resolver

lint Quality

Run linting and code quality checks on Ruby and ERB files.

skill: lint

spec-flow-analyzer Testing

Analyze user flows and identify gaps in specifications.

skill: spec-flow-analyzer

every-style-editor Content

Edit content to conform to Every's style guide.

skill: every-style-editor

Documentation Agent (1)

ankane-readme-writer Docs

Create READMEs following Ankane-style template for Ruby gems. Clean, concise, comprehensive documentation that gets straight to the point.

skill: ankane-readme-writer

19 Powerful Workflows

Workflows that replace entire manual processes. /review is your code review committee. /plan is your research team. /triage sorts 50 todos in the time it takes you to read five. Each one automates hours of work into a single line.

Core Workflows

/plan core

Create comprehensive implementation plans with research agents and stakeholder analysis.

/review core

Run exhaustive code reviews using 12 or more parallel agents, ultra-thinking, and worktrees.

/work core

Execute work items systematically with progress tracking and validation.

/compound core

Document solved problems to compound team knowledge. Turn learnings into reusable patterns.

Utility Workflows

/changelog util

Create engaging changelogs for recent merges.

/create-agent-skill util

Create or edit Agent skills with expert guidance.

/generate_command util

Generate new slash commands from templates.

/heal-skill util

Fix skill documentation issues automatically.

/plan-review util

Multi-agent plan review in parallel.

/prime util

Prime/setup command for project initialization.

/report-bug util

Report bugs in the plugin with structured templates.

/reproduce-bug util

Reproduce bugs using logs and console output.

/triage util

Triage and prioritize issues interactively.

/resolve_parallel util

Resolve TODO comments in parallel.

/resolve_pr_parallel util

Resolve PR comments in parallel.

/resolve_todo_parallel util

Resolve file-based todos in parallel.

/release-docs util

Build and update the documentation site with current plugin components.

/deploy-docs util

Validate and prepare documentation for GitHub Pages deployment.

12 Intelligent Skills

Domain expertise on tap. Need to write a Ruby gem? The andrew-kane-gem-writer knows the patterns Andrew uses in 50+ popular gems. Building a Rails app? The dhh-rails-style enforces 37signals conventions. Generating images? The gemini-imagegen has Google's AI on speed dial. Just invoke the skill and watch it work.

Development Tools

andrew-kane-gem-writer Ruby

Write Ruby gems following Andrew Kane's patterns. Clean APIs, smart defaults, comprehensive testing.

skill: andrew-kane-gem-writer

dhh-rails-style Rails

Write Ruby/Rails code in DHH's 37signals style. REST purity, fat models, thin controllers, Hotwire patterns.

skill: dhh-rails-style

dspy-ruby AI

Build type-safe LLM applications with DSPy.rb. Structured prompting, optimization, providers.

skill: dspy-ruby

frontend-design Design

Create production-grade frontend interfaces with modern CSS, responsive design, accessibility.

skill: frontend-design

create-agent-skills Meta

Expert guidance for creating Agent skills. Templates, best practices, validation.

skill: create-agent-skills

skill-creator Meta

Guide for creating effective Agent skills with structured workflows.

skill: skill-creator

compound-docs Docs

Capture solved problems as categorized documentation with YAML schema.

skill: compound-docs

Content & Workflow

every-style-editor Content

Review copy for Every's style guide compliance.

skill: every-style-editor

file-todos Workflow

File-based todo tracking system with priorities and status.

skill: file-todos

git-worktree Git

Manage Git worktrees for parallel development on multiple branches.

skill: git-worktree

Image Generation

gemini-imagegen AI Images

Generate and edit images using Google's Gemini API. Text-to-image, image editing, multi-turn refinement, and composition from up to 14 reference images.

Text-to-image generation

Image editing & manipulation

Multi-turn refinement

Multiple reference images (up to 14)

Google Search grounding (Pro)

skill: gemini-imagegen

Requires: GEMINI_API_KEY environment variable

Two MCP Servers

Playwright gives the agent a browser—it can click buttons, take screenshots, fill forms, and validate what your users actually see. Context7 gives it instant access to docs for 100+ frameworks. Need to know how Next.js handles dynamic routes? Context7 fetches the answer in real-time instead of hallucinating from outdated training data.

Playwright

Your AI can now see and click like a user. Test flows, grab screenshots, debug what's actually rendering.

Tools Provided: 6 tools

browser_navigate - Navigate to URLs
browser_take_screenshot - Take screenshots
browser_click - Click elements
browser_fill_form - Fill form fields
browser_snapshot - Get accessibility snapshot
browser_evaluate - Execute JavaScript

Context7

Stop getting outdated answers. Context7 fetches current docs from 100+ frameworks in real-time.

Tools Provided: 2 tools

resolve-library-id - Find library ID
get-library-docs - Get documentation

Supports: Rails, React, Next.js, Vue, Django, Laravel, and more than 100 others

Ready to Compound?

Install ag-cortex as a dev dependency. It manages the agent brain (skills, rules, workflows) inside your project while keeping your production bundle clean.

Add Package

npm install -D ag-cortex

Initialize

Run the install command to inject the .agent directory into your project root.

npx ag-cortex install

Ship Faster

# Basic invocation
skill: [agent-skill-name]

# Examples
skill: kieran-rails-reviewer
skill: security-sentinel "Audit the payment flow"

Frequently Asked Questions

What is Compounding Engineering?

It's the opposite of how most teams work. Normally, you fix a bug, ship it, and forget it. Next month someone hits the same bug and re-solves it from scratch. Compounding engineering means each fix teaches the system. Your third code review is faster than your first because the agents learned patterns. Your tenth security audit catches issues you missed in audit #2. The work accumulates instead of evaporating.

How do Agent Skills differ from Tool Skills?

Agent Skills are personas—they do things. The security-sentinel does security reviews. The kieran-rails-reviewer enforces Rails conventions. You call them directly: skill: security-sentinel.

Tool Skills are expertise the agent can tap into when needed. The dhh-rails-style knows 37signals Rails patterns. The gemini-imagegen knows how to generate images. The agent invokes them automatically when relevant, or you can explicitly call them: skill: dhh-rails-style.

Why aren't MCP servers loading automatically?

Yeah, we know. It's a current limitation. The workaround is simple: manually add the MCP servers to your config.json file. Check the README for copy-paste config. Takes 30 seconds and you're done.

Can I use this with languages other than Ruby/Rails?

Absolutely. We've got Python and TypeScript reviewers alongside the Rails ones. And the workflow commands, research agents, and skills like gemini-imagegen don't care what language you write. The security-sentinel finds SQL injection whether it's in Rails, Django, or Laravel.

How do I create my own agents or skills?

Run /create-agent-skill or invoke the create-agent-skills skill. Both give you templates, enforce best practices, and walk you through the structure. You'll have a working agent or skill in minutes instead of reverse-engineering from examples.