Recusive

Build and refine user interfaces with Tailwind CSS. Use when the user asks to build, design, style, or refine web UI — landing pages, dashboards, marketing sections, forms, buttons, cards, pricing tables, hero sections, testimonials, or Tailwind markup cleanup. Generates multiple design variations on exploratory requests.

Guide any engineering task — building, fixing, expanding, refactoring, investigating — like a senior engineer at a big company. Teaches the thinking process, not just rules. Study first, plan properly, implement with discipline. Use this skill whenever the user mentions "follow the patterns", "replicate the architecture", "proper system design", "production-ready plan", "do it properly", "don't hardcode", "build it like they would", "find the root cause", "fix it properly", "don't just patch it", "expand this feature", "refactor this", "how does this work", or asks for any engineering work to follow existing conventions exactly. Also trigger when the user is frustrated that previous work was half-baked, used hardcoded values, created workarounds, suppressed lints, or didn't follow the repo's architecture. Even if the user just says "plan this properly" or "I want it done right" or "check the codebase first", use this skill. When in doubt, prefer this skill — studying the codebase first never makes anything wo

Audit an implementation plan for Accessibility compliance. Use this skill when the user says "audit for accessibility", "a11y review this plan", "check accessibility", or any plan that adds interactive UI — buttons, dialogs, modals, forms, panels, trees, tabs, drag-and-drop, or custom widgets. Developer tools are notoriously poor at accessibility. This lens catches missing ARIA labels, broken keyboard navigation, trapped focus, insufficient contrast, and missing screen reader announcements that no other audit will find because they require thinking like a user who can't see the screen or use a mouse.

Audit an implementation plan through the eyes of a senior Backend/Rust Engineer. Use this skill when the user says "audit as backend", "backend review this plan", "review the Rust code", or any plan that involves Tauri commands, Rust crates, IPC protocol, sidecar processes, file system operations, terminal management, or backend state. This lens catches unsafe Rust patterns, error handling gaps, resource leaks, concurrency issues, and IPC protocol mistakes that frontend-focused audits miss entirely.

Audit an implementation plan through the eyes of a Design Engineer. Use this skill when the user says "audit as design engineer", "design review this plan", "review the design aspects", or any plan that involves UI changes, component styling, visual states, dark mode, colors, typography, spacing, or animations. Also trigger when reviewing plans that touch CSS, Tailwind classes, design tokens, or component visual structure. This lens catches visual inconsistencies, design system violations, and craft issues that other audits miss entirely.

Audit an implementation plan through the eyes of a Developer Experience (DX) Engineer. Use this skill when the user says "audit as DX", "DX review this plan", "review the developer experience", or any plan that adds user-facing features to a developer tool — CLI commands, error messages, configuration, onboarding, keyboard shortcuts, tool output, or API surfaces. Orbit is a developer tool; its users are developers. This lens catches the usability issues specific to developer tools that generic UX audits miss because they don't think like a developer using a tool.

Audit an implementation plan through the eyes of a senior Frontend Engineer. Use this skill when the user says "audit as frontend", "frontend review this plan", "review the React code", or any plan that involves React components, hooks, state management, Zustand stores, TypeScript types, CSS/Tailwind, bundle optimization, or rendering performance. This lens catches React anti-patterns, state management issues, type safety gaps, unnecessary re-renders, and bundle bloat that generalist audits miss.

Audit an implementation plan through the eyes of a Performance Engineer. Use this skill when the user says "audit for performance", "perf review this plan", "will this be fast", "check performance impact", or any plan that could affect runtime performance — new event listeners, state subscriptions, IPC calls, file I/O, streaming, rendering changes, process spawning, or features that run in long-lived sessions. This is NOT frontend render perf (that's frontend-eng). This is systems performance — memory over 8-hour sessions, IPC latency, streaming throughput, resource lifecycle. Desktop apps can't hide behind a page refresh.

Autonomous overnight codebase improvement agent. Runs for hours while you sleep — systematically discovers and fixes production-readiness issues across the entire stack: missing tests, error handling gaps, security vulnerabilities, accessibility problems, code quality violations, performance issues, and UI polish. Documents every finding and fix in a detailed shift log. The unattended runner supports both Codex and Claude as pluggable agent adapters — same pipeline, same verification, you just pick which one. Use this skill whenever the user says "nightshift", "run overnight", "overnight engineer", "night shift", "autonomous improvement", "improve while I sleep", "background improvement", "make production ready", "run all night", or wants to leave an agent running to systematically improve the codebase. Also trigger when the user mentions leaving the computer running overnight for code improvements, or wants a long-running autonomous session that explores and hardens the codebase.

The autonomous builder operator. Picks the highest-impact task from the queue, builds it end-to-end (code, tests, docs, changelog, tracker), ships via PR, and leaves a clean handoff for the next session. Invoke this operator when the daemon selects BUILD, when there are pending tasks to ship, when urgent work needs doing, or when the system needs features built. This is the default operator — when in doubt, build.

Autonomy engineering operator. Measures how close the system is to zero human intervention (0-100 score), identifies the highest-impact human dependency, and eliminates it with production-grade code. Invoke when the daemon selects ACHIEVE, when the autonomy score is below 70, when needs-human issues accumulate, or when the system has been running without self-reflection for 10+ sessions. This operator ships autonomy, not features.

Framework audit operator. Reviews all .recursive/ files for quality — contradictions between operators, dead paths, stale instructions, missing coverage. Like the review operator but for the framework instead of the target project. Invoke every 20+ sessions or after major framework changes.

Framework evolution operator. Reads the friction log written by target operators, finds patterns (same issue 3+ times), and fixes the root cause in .recursive/. Only modifies framework files — never touches the target project. Invoke when friction entries accumulate or repeated agent failures indicate systemic framework issues.

Task queue management operator. Triages every pending task — closes duplicates, marks done work, wontfixes stale noise, reorders priorities, and decomposes stuck tasks. Invoke when the daemon selects OVERSEE, when 50+ pending tasks accumulate, when stale tasks are piling up, or when the builder keeps skipping tasks. This operator makes the queue smaller and sharper so the builder builds the right thing.

Code quality review operator. Picks one file, reads it deeply, fixes every issue found, and logs the review. Invoke when the daemon selects REVIEW, after 5+ consecutive BUILD sessions, when the healer flags quality concerns, or when code quality debt is accumulating. This operator does not build features — it hardens what was already built.

Red team / pentest operator. Runs before the main build session to find the most fragile paths in the autonomous system and hand the builder a concise fix list. Invoke when the daemon runs pentest preflight, when security audit is needed, or when you want an adversarial review of the system's defenses. This operator is read-only — it finds breaks, it does not fix them.

Guide for creating effective skills. This skill should be used when users want to create a new skill (or update an existing skill) that extends Codex's capabilities with specialized knowledge, workflows, or tool integrations.

Install Codex skills into $ORBIT_HOME/skills from a curated list or a GitHub repo path. Use when a user asks to list installable skills, install a curated skill, or install a skill from another repo (including private repos).

Review Orbit Code diffs, branches, pull requests, or specific files for compliance with repo coding conventions. Use when the user asks to enforce conventions, check coding standards, audit a diff or branch, review merge readiness, or verify changes against AGENTS.md and docs/pattern/CODING_CONVENTIONS.md. Also use proactively before opening a PR or after substantial implementation work in this repo.

Use when the user asks how to build with OpenAI products or APIs and needs up-to-date official documentation with citations, help choosing the latest model for a use case, or explicit GPT-5.4 upgrade and prompt-upgrade guidance; prioritize OpenAI docs MCP tools, use bundled references only as helper context, and restrict any fallback browsing to official OpenAI domains.

Audit proposed refactor plans for production readiness in the Orbit Code monorepo. Use when asked to evaluate a plan document for correctness, architecture, crate boundaries, protocol and SDK compatibility, Bazel/Cargo/pnpm tooling fit, migration risk, edge cases, and test coverage before implementation.

Use this when you are working on file operations like reading, writing, scanning, or deleting files. It summarizes the preferred file APIs and patterns used in this repo. It also notes when to use filesystem helpers for directories.

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. Triggers on UI polish, design details, "make it feel better", "feels off", stagger animations, border radius, optical alignment, font smoothing, tabular numbers, image outlines, box shadows.

X/Twitter engagement agent that finds high-opportunity posts, drafts algorithm-optimized replies using Phoenix scoring knowledge, and posts them via browser automation. Use this skill whenever the user wants to engage on X, find posts to reply to, draft replies, do a speed reply to an X URL, monitor target accounts, check what's happening in their niche, plan reply strategy, or pastes any x.com URL. Also triggers on "x engage", "find opportunities", "reply to posts", "check targets", "post reply", "speed reply", "monitor X", or any discussion about X/Twitter growth, reply strategy, or engagement optimization.