Development skills

Build small, reliable automation scripts or workers within an active Codex Project Autopilot project, following its plan. The output includes execution logs and updated project state, with dry-run support for side effects and retries for external I/O when needed.

• Implementing an automation task in an active Autopilot project
• Adding a dry-run preview before actions with side effects
• Recording script actions and failures in an execution log

Use this skill as a practical guide when creating or maintaining a Julia package. It covers package layout, public APIs, multiple dispatch, type design, formatting, performance measurement, error handling, and documentation practices.

• Organize source files and a package entry point
• Design Julia APIs and types using multiple dispatch
• Format code and measure performance with Julia tools

Use this skill to assess code structure, module boundaries, dependencies, and interface stability before proposing changes. It helps keep designs aligned with existing patterns and favors small changes that reduce coupling and make future work easier to manage.

• Reviewing module boundaries before a change
• Reducing dependencies and coupling
• Checking whether an abstraction is premature

Simplifies code, plans, and systems while preserving required outcomes and constraints. For code, it measures per-function branching complexity, records changes, and adds a regression gate to the project’s normal verification path.

• Reducing complexity while refactoring code
• Removing dead code or guards that no longer serve a purpose
• Simplifying a roadmap or process without dropping requirements

Review whether earlier fixes are still active, then look for mistakes recurring across runs. For each recurrence, install and test an enforcement mechanism, or record why the team accepts having no mechanism.

• Checking whether promised fixes still run
• Finding recurring mistakes across project runs
• Adding and verifying a guard for a repeated failure

Build mobile apps locally and prepare them for App Store or Google Play submission. The workflow uses fastlane for builds and releases, checks metadata and device behavior before submission, and monitors staged rollouts for crashes.

• Preparing an iOS app for TestFlight or App Store review
• Building a signed Android release for Google Play
• Checking app metadata and device behavior before submission

Review code for five common quality concerns: input validation, edge cases, error handling, duplication, and complexity. It also checks whether automated quality gates produce trustworthy evidence, helping identify issues that need fixing before a change is ready.

• Review an implementation for common defects
• Check API input validation and error handling
• Find duplicated or overly complex code

Audits repository instruction files used by Claude Code and Codex, reports missing, generated, stale, or conflicting states, and can create a missing adapter from a declared source after confirmation. It preserves conflicts and records source and output provenance.

• Auditing CLAUDE.md and AGENTS.md status
• Generating a missing instruction adapter
• Checking for stale generated governance files

Run a structured development workflow that compares approaches, implements against tests, applies adversarial quality checks, and measures outcomes. It records findings and can revise the approach when experiments reveal brittleness or unmet expectations.

• Comparing implementation approaches before coding
• Iterating on code with tests and quality gates
• Checking a change for edge cases and security risks

Investigate bugs by reproducing the failure, testing possible causes, and tracing the root cause before proposing a fix and regression test. For refactoring, map dependencies, coupling, risks, and affected files into a change plan.

• Tracing an error from its visible symptom to the root cause
• Narrowing down a flaky test or intermittent failure
• Planning a refactor by mapping dependencies and risks

Review a branch against the project’s `.archcore/` records by checking whether changed code matches its documents and whether changed documents match the code. It reports which side is out of date, checks related plans and closeout, and can audit documentation gaps or stale records.

• Reviewing a branch before merging
• Checking whether project documents match changed code
• Auditing stale records and documentation gaps

Builds frontend interfaces inside an active Codex Project Autopilot project, following its approved plan and design direction. It implements responsive screens, covers key UI states, checks specified widths, and records implementation handoff details.

• Building a planned frontend screen in an active Autopilot project
• Implementing responsive layouts and key UI states
• Recording routes, backend placeholders, and checked screen widths

Design the data layer for an active Codex Project Autopilot project when its plan calls for one. The skill first checks whether a database is needed, then documents entities, ownership, access controls, and a maintainable schema or migration plan.

• Designing a data model within an Autopilot project
• Checking whether a planned feature needs a database
• Documenting entity ownership and access rules

Implement backend logic and integrations within an active Codex Project Autopilot project, following its approved plan. The skill validates inputs, handles errors and logs, and records implementation progress and required environment secrets for the next handoff.

• Implementing backend work from an approved Autopilot plan
• Wiring an integration with clear error handling
• Validating inputs and documenting required secrets

Handle email verification in agent signup and login flows with disposable inboxes. The skill can create an address, wait for a message, and extract an OTP code or magic link, with options for simulated mail in CI and inbox troubleshooting.

• Verifying a signup that sends an email
• Extracting an OTP or magic link for browser automation
• Testing email flows in CI without SMTP

Automatically simulate analog subcircuits detected from KiCad schematic analysis. Check values such as filter cutoff, divider output, op-amp gain, and resonance, then receive a structured pass, warning, or fail report with the selected simulator.

• Verify an RC or LC filter cutoff from a KiCad schematic
• Check a voltage divider or op-amp stage by simulation
• Review crystal load capacitance or circuit resonance

Use this skill to structure a Julia package as a standalone command-line app. It explains how to add a `@main` entry point and declare executable names in `Project.toml`, so users can run the installed app from a terminal with arguments.

• Turn a Julia package into a command-line app
• Add an entry point that handles terminal arguments
• Declare executable names in Project.toml

Start new work by classifying the request, researching and verifying an approach, then defining scope and success checks. For resumed work, validate a handoff or checkpoint manifest, compare it with the current repository, and prepare bounded context for continuing at the right phase.

• Scope a new feature or bug fix
• Research and verify an implementation approach
• Resume work from a checkpoint manifest

Within an active Codex Project Autopilot project, turn discovery or approval inputs into a scoped implementation plan. Compare minimum, balanced, and expanded options, recommend one in plain language, and record deliverables, acceptance criteria, risks, and needed manual steps.

• Planning implementation after project discovery
• Comparing three scope and effort options
• Choosing a practical technology stack for an MVP

Review pull requests or staged code changes for correctness, security, edge cases, error handling, duplication, and complexity. It reports findings above its confidence threshold and returns an APPROVE, REQUEST CHANGES, or COMMENT verdict with suggested fixes.

• Review a pull request before merging
• Check staged changes for security and logic issues
• Get a verdict with confidence-rated findings

Turn a company website into a tailored agentfront, an AI-centered web experience. The skill researches the company’s products, customers, pricing, and brand, then adapts a Next.js template with relevant content, page sections, calls to action, and visual assets.

• Transforming a company website URL into an agentfront
• Building an agent-first experience for a product catalog
• Adapting a web template to a company’s brand and customer intent

Manage an electronics project's bill of materials from schematic review through sourcing and order preparation. It identifies missing part data, coordinates distributor lookups, records validated details in KiCad properties, and exports tracking or fabrication files.

• Finding missing part numbers and sourcing details in a schematic
• Comparing distributor stock and pricing for a target quantity
• Exporting a BOM or distributor order files

Use Waggle to recall relevant project decisions and constraints during substantial coding tasks, then save durable outcomes such as verified fixes or lasting requirements. The memory is scoped to the project and stored locally.

• Recall earlier project decisions before changing code
• Check constraints that may affect an implementation
• Save a verified bug fix for future project work

Execute an AgiFlow work unit by reviewing its tasks and dependencies, implementing them in order, testing between tasks, and recording status and progress through MCP tools. It can prepare a completion summary and draft commit and PR text after all tasks reach Review or Done.

• Implement a feature organized as an AgiFlow work unit
• Work through dependent tasks in the right order
• Track task status and testing progress