crbnos/carbon

Browser automation CLI for AI agents. Use when the user needs to interact with websites, including navigating pages, filling forms, clicking buttons, taking screenshots, extracting data, testing web apps, or automating any browser task.

A browser automation CLI for AI agents to navigate websites, fill forms, click buttons, take screenshots, extract data, and automate browser tasks.

Captures screenshot and element snapshot on browser errors during e2e testing, saving to gitignored .ai/scratch/e2e/. Invoke when 'Something went wrong', auth errors, blank pages, or unexpected redirects appear. A building block that captures and returns, leaving further action to the caller.

Browser Feature Testing drives the running Carbon app through a specific user flow in a real browser to verify a feature or fix works end to end. It builds a plan from the diff or an issue, tests with agent-browser, and caches successful playbooks for reuse.

Orchestrates the bug-fix lifecycle from root cause analysis to implementing and proving the fix with a mandatory red→green regression test. Use when fixing a bug, test failure, or unexpected behavior.

Authenticate against a local Carbon ERP dev server using the DEV_BYPASS_EMAIL bypass with agent-browser. Used as a prerequisite for automated tests that require an authenticated session.

Helps write and maintain documentation for the Carbon manufacturing platform (ERP+MES) using its Fumadocs site. Guides authoring in the house style with real MDX components and source-grounded verification.

Author and edit the Carbon documentation site, including editorial Guide chapters and Reference entity pages. Follows a grounded-in-source workflow with flow-based architecture and build verification.

Runs pre-commit verification gates (types, format, typecheck, tests, i18n) in order, automatically fixes linting and formatting errors, and commits only when all checks pass. Use after completing a task or making changes to ensure code quality before committing.

Runs validation gates (type generation, linting, typecheck, tests, i18n) on changed files, auto-fixes issues, and commits only when everything passes. Use after code changes to ensure a safe commit.

Surveys how best-in-class ERPs and point solutions implement a feature, producing a structured findings file. Use when designing a new feature, evaluating approaches, or answering industry-standard questions.

Automates the iterative development of a single, tightly-scoped work item (bug, tweak, small feature) by running a doer→gate→judge cycle unattended, producing a gated pull request as the only human supervision point.

Creates or refreshes an AGENTS.md for Carbon packages or ERP modules by reading source code, grounding every claim in real functions, tables, and exports. Ideal when adding modules or performing freshness audits.

Generates or refreshes an AGENTS.md for a Carbon package or ERP module by reading actual source code, verifying every claim against real functions, tables, and exports. Use when adding a new module, when audits flag a stale file, or on request.

A systematic debugging approach: add temporary JSONL logging to the real code path, reproduce the bug, and analyze runtime events to find the exact point of divergence before fixing. Use when static analysis gives low confidence or the bug involves runtime state, ordering, concurrency, or manual reproduction.

Captures screenshot and element snapshot of current browser page when an error appears during e2e testing. Saves to gitignored .ai/scratch/e2e/. Use when agent-browser snapshot shows failure indicators. Building block: captures and returns, caller decides to continue.

Executes an approved implementation plan task by task, running verifications and committing each task via a check-and-commit gate. Use after /plan approval for automated, verifiable implementation of software plans.

Executes an approved implementation plan step by step, running verifications and committing per task. Use after a plan is approved to turn it into working, tested code.

Orchestrates the complete feature lifecycle from research and spec writing to plan, build, test, and self-review. Supports autonomous and approval-based modes with structured run records.

An end-to-end bug-fix pipeline that diagnoses root causes, implements minimal fixes with regression tests, and optionally verifies and commits. Use for fixing bugs, test failures, or unexpected behavior.

Interviews the user relentlessly, one question at a time, to resolve every open decision in a plan, spec, or design idea. Cross-checks answers against the codebase and domain glossary, records resolutions immediately, and surfaces contradictions. Supervised use only.

A supervised interview skill that resolves every open decision in a plan or spec by asking one question at a time, cross-checking answers against the codebase, and recording resolutions immediately. Use when you need to thoroughly stress-test a design before implementation.

Generates a detailed implementation plan from a finalized spec, breaking work into verifiable tasks with exact file paths, commands, and expected outputs for an AI agent to execute mechanically.

Audits the Carbon codebase as a senior advisor to surface improvement opportunities (bugs, security, performance, test coverage, tech debt, migrations, DX) and produces self-contained implementation plans for other AI agents to execute. Strictly read-only; never modifies code.

Surveys the Carbon codebase as a senior advisor to produce prioritized, self-contained implementation plans for other agents to execute. Ideal for finding improvement opportunities and generating handoff plans without modifying code.

Reference for Inngest durable functions and background jobs, covering v3 syntax, steps, events, flow control, error handling, and local development. Use when writing or reviewing Inngest functions.

Reference for Inngest v3 durable functions in Carbon. Use when writing or reviewing Inngest functions, managing concurrency, throttling, debouncing, and debugging retries in Carbon's background jobs.

Design engineering principles for making interfaces feel polished. Use when building UI components, reviewing frontend code, implementing animations, hover states, shadows, borders, typography, micro-interactions, enter/exit animations, or any visual detail work.

Design engineering principles for polished interfaces: typography, animations, surfaces, and performance. Use when building or reviewing UI components to add micro-interactions, shadows, and optical alignment.

Generates a self-contained HTML page that explains a pull request's purpose, changes, and verification, helping reviewers quickly understand complex changes without reading the full diff.

Generates a standalone HTML page that explains a pull request's changes, including the problem, system context, before/after flow, and verification evidence. Use it to help reviewers understand complex changes quickly without relying on GitHub.

Break a large pull request into smaller, reviewable PRs (stacked or parallel) while preserving all original work. Use when a PR is too big, mixes refactors with features, or requires incremental delivery.

Creates a detailed, executable implementation plan from a finalized specification, breaking down work into verifiable tasks with exact file paths, commands, and expected outputs. For use in agent-assisted development workflows to plan implementation steps before execution.

Surveys how best-in-class ERPs implement features and produces a structured findings file. Use before designing ERP-domain features like accounting, inventory, or manufacturing.

Performs read-only root cause analysis for bugs, test failures, and unexpected behaviors. Produces a brief identifying the root cause, files to change, approach, and risks, without making any edits or state changes.

Performs read-only root-cause analysis for bugs, test failures, or unexpected behavior, producing a structured brief with the cause, files to change, approach, and risks. Use before proposing any fix or when the cause isn't proven.

Rust coding conventions for Carbon's cargo workspace, emphasizing safe async/FFI patterns, ownership choices, error handling, and performance profiling when working with OpenCASCADE and FCL bridges.

Provides guidelines for writing idiomatic Rust code, covering borrowing, error handling, performance, testing, and documentation. Use when writing, reviewing, or refactoring Rust code.

Critically reviews your own branch diff against main before opening or merging a PR, identifying must-fix issues, risks, improvements, and docs-freshness checks. Supports an opt-in strict thermo-nuclear mode for deep maintainability audits.

Quick end-to-end smoke test of the local Carbon ERP dev server: logs in and verifies core modules (dashboard, sales, purchasing, etc.) render without errors. Use after booting, broad changes, or when asked to smoke test.

Guides feature design by researching competitors, surfacing open questions, and interviewing stakeholders before writing the spec. Use for new modules, data model changes, or changes across 3+ files.

Guides feature design and spec writing by researching competitors, making design decisions, and resolving open questions before writing the spec document. Use for new features, modules, data model changes, or cross-module changes.

Supabase Postgres Best Practices covers query, schema, connection, and RLS guidance for Postgres. Use it when writing, reviewing, or tuning SQL and database configuration.

Test-Driven Development enforces writing a failing Vitest test before production code in Carbon. Use it for features and bug fixes when you need a regression-safe red→green→refactor loop.

Translate fills missing Lingui .po msgstr entries in locale catalogs using cheap Haiku subagents, then merges and verifies the results. Use it after adding UI strings or when you need to run the translation workflow without overwriting existing translations.

UI helps you explore, build, and refine user interfaces. Use it when working on frontend layouts, component behavior, or visual polish.

Writing Skills defines how Carbon skills are authored and reviewed in this repo. Use when creating a new skill, restructuring an existing one, or checking a skill for frontmatter, install wiring, templates, and weak-executor rules.