ulpi-io

Process documents with the Nutrient DWS API. Use this skill when the user wants to convert documents (PDF, DOCX, XLSX, PPTX, HTML, images), extract text or tables from PDFs, OCR scanned documents, redact sensitive information (PII, SSN, emails, credit cards), add watermarks, digitally sign PDFs, fill PDF forms, or check API credit usage. Activates on keywords: PDF, document, convert, extract, OCR, redact, watermark, sign, merge, compress, form fill, document processing.

When the user wants to optimize images for search engines and performance. Also use when the user mentions "image SEO," "alt text," "image captions," "figcaption," "image optimization," "WebP," "lazy loading," "LCP," "image sitemap," "responsive images," "srcset," "image format," or "hero image optimization."

Diagnose and fix bugs with root-cause analysis and verification. Use when you have a concrete issue report, failing behavior, runtime error, or test regression that should be resolved safely. For ambiguous, high-risk, or broad-scope issues, stop and route to write-plan first.

Stores decisions and patterns in knowledge graph. Use when saving patterns, remembering outcomes, or recording decisions.

Unified decision tree for web research and competitive monitoring. Auto-selects WebFetch, Tavily, or agent-browser based on target site characteristics and available API keys. Includes competitor page tracking, snapshot diffing, and change alerting. Use when researching web content, scraping, extracting raw markdown, capturing documentation, or monitoring competitor changes.

Never test mock behavior. Never add test-only methods to production classes. Understand dependencies before mocking. Language-agnostic principles with TypeScript/Jest and Python/pytest examples.

Vercel deployment lifecycle for builds, deployments, previews, release phases, and rollback. Use when configuring build output, deployment workflows, or release controls on Vercel.

Create and manage stacked (dependent) pull requests for complex features

Answer Engine Optimization (AEO) audit and SERP analysis for AI-generated answers. Analyzes pages for AEO readiness (structured data, FAQ patterns, heading hierarchy, meta quality) and checks how queries appear in AI-powered search results (Google AI Overviews, Perplexity, ChatGPT Search). Uses the browse CLI for all page interaction.

Guided configuration generator for the browse CLI's camoufox integration. Asks the user questions to build a browse.json camoufox section or a named profile JSON file for stealth, fast-scraping, Google-safe, or custom setups.

Generative Engine Optimization (GEO) monitoring — track brand and domain visibility across AI-powered search engines: Google AI Overviews, Perplexity, and ChatGPT Search. Run multi-query sweeps, detect citations, measure domain presence, and generate cross-engine visibility reports. Uses the browse CLI with camoufox for stealth.

SEO auditing for AI agents using the browse CLI. Extracts meta tags, headings, structured data, performance metrics, link structure, and mobile rendering. Generates actionable audit reports with findings and recommendations. Works with any URL.

Fast web browsing, web app testing, and native app automation for AI coding agents. Persistent headless Chromium for web. Android, iOS, and macOS app automation via accessibility APIs. Browse URLs, read content, click elements, fill forms, run JavaScript, take screenshots, automate native apps — all through the same CLI and @ref workflow. ~100ms per command. Auto-installs Android toolchain. Works with Claude Code, Cursor, Cline, Windsurf, and any agent that can run Bash.

Stealth browsing with the camoufox runtime for AI agents. Covers Cloudflare Turnstile bypass, Google anti-bot evasion, authenticated sessions, and proxy rotation. Uses the browse CLI with --runtime camoufox and named camoufox profiles.

QA a web or app feature from a ticket, URL, acceptance criteria, or plain-language description, then generate reusable browse flows for regression coverage. Uses the `browse` skill for the actual browser or simulator interaction and keeps the QA loop focused on scenarios, evidence, and report quality.

Fast web browsing, web app testing, and native app automation for AI coding agents. Persistent headless Chromium for web. Android, iOS, and macOS app automation via accessibility APIs. Browse URLs, read content, click elements, fill forms, run JavaScript, take screenshots, automate native apps — all through the same CLI and @ref workflow. ~100ms per command. Auto-installs Android toolchain. Works with Claude Code, Cursor, Cline, Windsurf, and any agent that can run Bash.

Write and change Laravel the way THIS project already does it, with Laravel 13 as the recommended baseline for new applications and explicit compatibility handling for existing versions. Carries the real controller/Action/Resource boundaries and conventions for thin controllers, Form Request validation, strict Eloquent, API Resources, Horizon queues, caching, auth, observability, and the Laravel AI/Boost/MCP stack. Use when a task touches this project's Laravel code and should follow its backend conventions rather than generic or outdated framework defaults.

Build Next.js the way THIS project's App Router already works, with the current stable Next.js 16.2 line recommended for new applications and explicit compatibility handling for existing versions. Carries the real server/client boundaries and conventions for pages, layouts, async request APIs, the project API-client data layer, Server Actions, Cache Components, metadata, i18n, accessibility, analytics, and testing. Use when a task touches this project's Next.js App Router surface and should follow its conventions rather than generic or prerelease defaults.

Take one feature request from prompt to reviewed, audited delivery in a SINGLE autonomous pass — one runnable Workflow that plans, reviews the plan, builds task by task, cross-reviews the build, and optionally runs a launch audit, then RETURNS the verified findings rather than looping (the user decides any fix round; a Workflow can't ask mid-run, and an autonomous fix-loop is what caused multi-hour grinds). It chains the existing skills — plan-to-task-list-with-dag (a specialist agent per task) → plan-founder-review → a specialist engineer/reviewer build across the DAG → a full claude ∥ codex/kiro cross-review → go-live-audit — and FOLLOWS the graph strictly: every task declares its dependencies, layers must be a topological order, plan review blocks a mis-ordered graph, and a task NEVER builds before its dependencies integrate (no building on a broken base). Per-task review is SLICE-SCOPED (judges only that task's own change against its acceptance criteria, attributing whole-codebase end-state gaps to the ta

Search code by SYNTAX SHAPE, not by text — matching structures grep and regex can't reliably express — with the `ast-grep` CLI: parse to an AST and match with patterns, node kinds, relational rules (`inside`/`has`), and metavariables, inspecting the tree via `--debug-query` and proving the rule on a minimal example before it runs repo-wide. Requires the `ast-grep` CLI; results are spot-checked, not returned as unverified noise. Use when the target is a code structure rather than a literal string.

Gate a branch before it becomes a PR — catch the STRUCTURAL defects tests miss, not style: read the full diff against the default base, run a two-pass checklist (blocking pass first — unsafe queries, race conditions, trust-boundary and auth mistakes, conditional side effects — then the non-blocking remainder), and verify each candidate against surrounding code before reporting. Stays read-only and reports blocking-first; only becomes mutating after you explicitly approve a specific fix per issue — never batches decisions or auto-fixes. Use as the branch gate right before shipping or opening a PR.

Score a page for how well AI answer engines can CITE it — Answer Engine Optimization, not classic rankings — by pulling structured data, meta, headings, and answer-shaped content via the `browse` CLI (schema/meta/headings/text) into a weighted 0-100 audit, plus a SERP mode that reads Google AI Overviews, Perplexity, and ChatGPT Search snapshots to see who actually gets cited. Never fabricates a score: an un-evaluable dimension is marked N/A, and "appears in AI Overviews" is asserted only after a real SERP check. Use to make a page answer-ready or to check its AI-answer visibility.

Generate camoufox configuration for the `browse` CLI by INTERVIEW, not hand-edited JSON — an AskUserQuestion-guided flow that turns a chosen preset (stealth, fast-scraping, Google-safe, or a fully custom walkthrough) into a valid `browse.json` camoufox section or a named `.browse/camoufox-profiles/<name>.json`, using camelCase keys, merging without clobbering existing fields, and writing proxy credentials to file only. Use to create or tune an anti-detection browse profile before stealth browsing.

Track brand and domain VISIBILITY across AI search engines over a whole query set — Generative Engine Optimization monitoring, not a one-page audit — sweeping each query through Google AI Overviews, Perplexity, and authenticated ChatGPT Search via the `browse` CLI (camoufox for Google), recording each citation into a cross-engine visibility matrix with rates, average position, and competing domains. Reports point-in-time truth: ambiguous citations flagged uncertain, nothing fabricated. Use to monitor a brand's AI-answer presence across engines and queries.

Implement a whole DAG plan autonomously — one approved pass, one clean rollback point per task, never building on a broken base. It requires an approved plan (specced upstream) and a clean git baseline, takes a SINGLE human approval of the plan, then walks the DAG layer by layer: for each task it implements on an isolated worktree branch test-first (RED → GREEN), integrates the slice onto the working branch, reviews the integrated change, runs a bounded fix loop until the task passes, and commits it individually — so any point is a clean rollback. It follows the dependency graph strictly (a task builds only once its deps integrate), checkpoints every task so it resumes exactly where it stopped, and STOPS-and-asks on unfixable failures, ambiguity, or irreversible steps rather than pushing through. This is the BUILD phase. Composes fan-out-work (per layer), converge-loop (per-task fix), adversarial-verify (per-task review), checkpoint-resume, and budget-guard.

Turn a spec into a self-reviewed DAG of atomic build tasks: each task gets acceptance criteria, a disjoint write scope (≤3 files), and a slice-scoped validate; dependencies are wired and layered topologically so nothing builds on a missing base. Adversarial critics then attack the graph (cycles, phantom paths, coverage vs spec, task independence) until it is clean. Writes .ulpi/plans/<name>.json. Use when a spec needs an implementable, ordered breakdown before building.

Turn a raw feature request into a grounded, TESTABLE spec — autonomously. It recons the real repo and domain to ground every claim, drafts a spec (objectives, user-visible behavior, acceptance criteria, explicit non-goals, constraints, interfaces, risks), then runs a completeness-critic loop that adversarially hunts for gaps, ambiguity, and untestable criteria and fixes them until the spec is stable. Every acceptance criterion it emits is measurable (you could write a test for it); every requirement is grounded in the repo or flagged as an assumption — no invented requirements, no phantom paths. It writes `.ulpi/spec/<name>.md` and is the DEFINE phase that feeds auto-plan. Composes fan-out-work (recon), adversarial-verify (the critic), converge-loop (until-stable), and checkpoint-resume.

Run the whole engineering lifecycle end-to-end from one request — spec → plan → build → simplify → test → review → performance → ship — as a single autonomous pass with ONE human approval (the plan) and hard-gated escalation for anything irreversible. It chains the auto-* phase skills, carries a durable pipeline checkpoint so a stop/crash resumes at the exact phase and task it left off, watches the signal between phases (a phase that misses its gate is recorded blocked and surfaces in the register — fail closed, no false-green downstream), and returns a verified findings register at the end. Autonomous: it AUTO-FIXES the confirmed findings in a bounded converge-loop (never asking permission to fix), returning only the residual it can't converge within budget or a fix needing an irreversible/ambiguous decision. This is the top-level "maximise autonomous agents" entry point. Composes every auto-* phase plus checkpoint-resume, budget-guard, watch-and-act, and adversarial-verify.

Make long autonomous work durable and resumable: a live .ulpi/runs/<id>.json status file (per-unit + per-phase state, atomic locked writes via the bundled scripts/checkpoint.mjs CLI) that a resume reads to SKIP everything already done — session-independent. Status writes are non-fatal observability. Use for any multi-unit run worth resuming after a stop or crash.

Review a change across every dimension at once, then keep only the findings that survive an adversarial check — autonomously. It fans out independent reviewers over the diff (correctness, security, performance, maintainability/readability, test adequacy, API/contract & compatibility), dedups their findings, and puts each through a majority-refute verification so false positives never reach you or drive a fix. Survivors come back severity-labeled and actionable (file:line, why, suggested fix), and — if you ask — a bounded fix loop resolves the confirmed blockers. It fails closed: a dimension that didn't actually run is reported as a gap, never as "clean". This is the REVIEW phase. Composes fan-out-work (dimensions), adversarial-verify (confirm findings), converge-loop (optional fix), and checkpoint-resume.

Cover a large work-list in parallel without losing correctness or honesty — scout the items inline, then run each through its stages concurrently (map, optionally reduce) via the Workflow tool, with concurrency caps, per-item isolation where items mutate files, and an explicit account of anything dropped. Use when the task is "do the same thing to N independent things" — audit every module, migrate every call site, write tests for every gap, review every changed file — and N is big enough that serial is wasteful. It keeps the coordinator in control of the decision to continue while the per-item work runs in agents; it never silently truncates (a top-N/sampling cap is logged), and it aggregates results faithfully (a failed item becomes a reported null, not a hidden success). Composes with converge-loop (per-item loops) and adversarial-verify (gate each item's result).

Take verified work to shippable — autonomously, with fail-closed gates and a human sign-off on anything irreversible. It runs the pre-launch gate (final validate green, review clean, security/observability/ rollback checks), and a gate that DIDN'T actually run is treated as a blocker, never as clean. Then it prepares the release: atomic commits, a changelog/release notes grounded in the actual changes, version bump, docs for user-visible/API changes — and opens the PR (or stages the rollout: feature flag + rollback path + monitoring). The deploy itself is gated on explicit human approval. It fails closed and never fabricates a green gate to ship. This is the SHIP phase. Composes adversarial-verify (confirm the "ready" claim), checkpoint-resume, and budget-guard.

Review a change across every dimension at once, then keep only the findings that survive an adversarial check — autonomously. It fans out independent reviewers over the diff (correctness, security, performance, maintainability/readability, test adequacy, API/contract & compatibility), dedups their findings, and puts each through a majority-refute verification so false positives never reach you or drive a fix. Survivors come back severity-labeled and actionable (file:line, why, suggested fix), and — if you ask — a bounded fix loop resolves the confirmed blockers. It fails closed: a dimension that didn't actually run is reported as a gap, never as "clean". This is the REVIEW phase. Composes fan-out-work (dimensions), adversarial-verify (confirm findings), converge-loop (optional fix), and checkpoint-resume.

Make long autonomous work durable and resumable: a live .ulpi/runs/<id>.json status file (per-unit + per-phase state, atomic locked writes via the bundled scripts/checkpoint.mjs CLI) that a resume reads to SKIP everything already done — session-independent. Status writes are non-fatal observability. Use for any multi-unit run worth resuming after a stop or crash.

Implement a whole DAG plan autonomously — one approved pass, one clean rollback point per task, never building on a broken base. It requires an approved plan (specced upstream) and a clean git baseline, takes a SINGLE human approval of the plan, then walks the DAG layer by layer: for each task it implements on an isolated worktree branch test-first (RED → GREEN), integrates the slice onto the working branch, reviews the integrated change, runs a bounded fix loop until the task passes, and commits it individually — so any point is a clean rollback. It follows the dependency graph strictly (a task builds only once its deps integrate), checkpoints every task so it resumes exactly where it stopped, and STOPS-and-asks on unfixable failures, ambiguity, or irreversible steps rather than pushing through. This is the BUILD phase. Composes fan-out-work (per layer), converge-loop (per-task fix), adversarial-verify (per-task review), checkpoint-resume, and budget-guard.

Run the whole engineering lifecycle end-to-end from one request — spec → plan → build → simplify → test → review → performance → ship — as a single autonomous pass with ONE human approval (the plan) and hard-gated escalation for anything irreversible. It chains the auto-* phase skills, carries a durable pipeline checkpoint so a stop/crash resumes at the exact phase and task it left off, watches the signal between phases (a phase that misses its gate is recorded blocked and surfaces in the register — fail closed, no false-green downstream), and returns a verified findings register at the end. It does NOT loop on its own: after one pass it reports what shipped and what's open, and the user decides on any fix round. This is the top-level "maximise autonomous agents" entry point. Composes every auto-* phase plus checkpoint-resume, budget-guard, watch-and-act, and adversarial-verify.

Turn a spec into a self-reviewed DAG of atomic build tasks: each task gets acceptance criteria, a disjoint write scope (≤3 files), and a slice-scoped validate; dependencies are wired and layered topologically so nothing builds on a missing base. Adversarial critics then attack the graph (cycles, phantom paths, coverage vs spec, task independence) until it is clean. Writes .ulpi/plans/<name>.json. Use when a spec needs an implementable, ordered breakdown before building.

Cover a large work-list in parallel without losing correctness or honesty — scout the items inline, then run each through its stages concurrently (map, optionally reduce) via the Workflow tool, with concurrency caps, per-item isolation where items mutate files, and an explicit account of anything dropped. Use when the task is "do the same thing to N independent things" — audit every module, migrate every call site, write tests for every gap, review every changed file — and N is big enough that serial is wasteful. It keeps the coordinator in control of the decision to continue while the per-item work runs in agents; it never silently truncates (a top-N/sampling cap is logged), and it aggregates results faithfully (a failed item becomes a reported null, not a hidden success). Composes with converge-loop (per-item loops) and adversarial-verify (gate each item's result).

Turn a raw feature request into a grounded, TESTABLE spec — autonomously. It recons the real repo and domain to ground every claim, drafts a spec (objectives, user-visible behavior, acceptance criteria, explicit non-goals, constraints, interfaces, risks), then runs a completeness-critic loop that adversarially hunts for gaps, ambiguity, and untestable criteria and fixes them until the spec is stable. Every acceptance criterion it emits is measurable (you could write a test for it); every requirement is grounded in the repo or flagged as an assumption — no invented requirements, no phantom paths. It writes `.ulpi/spec/<name>.md` and is the DEFINE phase that feeds auto-plan. Composes fan-out-work (recon), adversarial-verify (the critic), converge-loop (until-stable), and checkpoint-resume.

Use when user has just installed framework agents and CLAUDE.md contains generic examples - systematically discovers actual project patterns (custom commands, architecture decisions, team conventions) and updates CLAUDE.md and imported files with real project-specific information

Automatically orchestrate multiple specialized agents working in parallel when building independent features, modules, or performing separate investigations. Use when the task list contains 3+ unrelated features/tasks that don't share state, don't have execution dependencies, and can be understood independently. Match each feature to the right expert agent (Laravel, Next.js, React, Node, NestJS, Remix, Express, Expo, Flutter, Magento) and run them concurrently to maximize development speed.

Automatically orchestrate multiple specialized agents working in parallel to debug, diagnose, and fix independent problems across different subsystems. Use when encountering 3+ unrelated bugs, test failures, or issues in isolated modules that don't share root causes. Match each problem to the right expert agent (Laravel, Next.js, React, Node, NestJS, Remix, Express, Expo, Flutter, Magento) to diagnose and resolve issues concurrently, maximizing debugging efficiency.

MANDATORY for starting any conversation or task. Establishes required workflows: discovering and using skills, invoking the Skill tool before announcing usage, performing brainstorming before coding, creating TodoWrite todos for all checklists, and selecting/invoking the correct specialized agent persona for the task domain.

Use when creating new agent configurations, editing existing agents, or syncing agents between Claude Code and ULPI formats. Ensures agents follow proper structure with concise examples and consistent formatting across both systems.

Use when creating new skills, editing existing skills, or verifying skills work before deployment. Combines TDD methodology (RED-GREEN-REFACTOR cycle), Anthropic best practices (progressive disclosure, token efficiency), and research-backed persuasion principles for bulletproof skill documentation.