Public directory

Generate a branching health report analysing git branch hygiene, merge patterns, and history readability. Compares key metrics with the previous report and oldest baseline when they exist.

Run a disciplined first pass over any new dataset: shape, quality, distributions, relationships, and a findings memo.

Audits every claim in a readme against the repository and rewrites the stale sections whenever setup docs drift from reality.

Tutor by questioning: diagnose the real misconception, ladder hints instead of answers, and let the learner earn the insight.

Build day-by-day itineraries that survive real travel: one anchor per day, geographic clustering, honest pacing, written contingencies.

Turn open-ended web research into a source-ranked extraction table with triangulated claims and citations.

Writes, debugs, and optimizes SQL from schema and grain, with cost notes and safe write rituals, whenever a question needs a query.

Tailor a resume to one job posting: map requirements to true evidence, rewrite the bullets that argue fit, cut what does not sell.

Turns a release range of commits into user-facing changelog entries with migration notes whenever you cut or backfill a release.

Build, test, and document regular expressions against a real example corpus instead of guessing and hoping.

Write trigger-driven product emails with one job each: sequence map, exit criteria, plain-text-first bodies, single CTAs.

Produce honest weekly status reports: a defensible RAG call, shipped-not-busy progress, owned risks, and explicit asks.

Structure a sales or fundraising pitch as a narrative arc — shift, stakes, route, proof, ask — with a slide-by-slide skeleton.

Build and debug spreadsheet formulas that survive real data: lookups, conditional math, dates, and error handling.

Plan search-targeted articles from intent outward: outline, direct-answer block, titles, links — a brief a writer can run cold.

Organize hiring into a pipeline that holds: staged SLAs, scorecards before interviews, weekly reviews, and no silent candidates.

Plan large codebase migrations as reversible, shippable waves with an inventory, order of attack, and rollback story.

Define a metrics tree from north star to input drivers, with one owner and one unambiguous definition per metric.

Restructure messy draft reports into a standalone summary, ranked findings, and traceable recommendations — losing nothing.

Digest raw feedback into ranked problem themes with counts, severity, representative quotes, and recommended actions.

Turn static mockups, screenshots, or sketches into semantic, responsive HTML and CSS with a layout-first build order.

Compute realistic sprint capacity from the actual calendar — leave, meetings, interrupts — then fit scope under a commit line.

Decide what earns a place in an LLM context window: budget tokens by tier, compress the rest, and order for recall.

Merge many sources into one brief: claims extracted, evidence graded, contradictions surfaced, findings ranked by confidence.

Scaffold a typed, tested client library around any HTTP API, with auth, pagination, retries, and errors handled once.

Turn transcripts or rough notes into decision-first minutes with owned actions, due dates, and a two-minute read.

Stress-test a paper claim by claim: design ceilings, effect sizes, and verdicts on whether conclusions outrun the data.

Draft specs precise enough to disagree with: goals and non-goals, costed options, testable acceptance criteria, owned questions.

Outline decks with assertion titles and one idea per slide, so the argument works before anyone touches design.

Draft business agreements from deal terms: structured intake, clean clause skeleton, balanced obligations, and a counsel checklist.

Design A/B tests worth running: falsifiable hypothesis, one decision metric, sized samples, a pre-committed analysis.

Design pricing tests that end in a decision: hypothesis, fair treatment, guardrails, and a pre-committed call rule.

Reconcile accounts payable in strict passes: match invoices to statements, classify every leftover, and draft corrections for review.

Plan format conversions that name what will break — footnotes, tables, tracked changes — and verify output against a checklist.

Clean messy tabular data in a fixed order — profile, structure, types, missing, duplicates, outliers — with an audit trail.

Apply proven prompt structures — contracts, examples, decomposition — and iterate against a test set, not vibes.

Write cover letters that argue fit instead of repeating the resume: one thesis, two proof stories, a falsifiable why-them.

Produces verified API reference docs from routes and schemas whenever endpoints are undocumented, stale, or newly shipped.

Run a structured conversion teardown of a landing page: message match, proof, friction, and one focused call to action.

Diagnose slow code by measuring first: profile, isolate the hotspot, fix one thing, and prove the win with numbers.

Assemble a decision-ready competitor brief: capability gaps, positioning, pricing posture, and where you win or lose.

Designs database schemas from workload to DDL — constraints, keys, indexes, migrations — whenever tables are created or reworked.

Rewrite dense text for first-pass comprehension: front-loaded point, short sentences, rescued verbs, zero meaning drift.

Guide reflective journaling with one prompt at a time, gentle follow-ups, and consent-based pattern reviews of past entries.

Assemble a first-week context pack for a new hire: role charter, people map, systems by day needed, glossary, and a checkable 30-60-90.

Write one-task help articles users can finish without a ticket: prerequisites, observable steps, and built-in troubleshooting.

Split work across multiple AI agents with clear roles, handoff contracts, and verification so parallelism stays safe.

Audit and rewrite page titles, meta descriptions, and social preview tags so every URL earns its click.

Turn goals and content pillars into a four-week social calendar with hooks, formats, and repurposing built in.

Coach generative art from seed idea to curated series: constraints first, seeded randomness, palette roles, ruthless curation.

Reviews infrastructure-as-code changes via the rendered plan — blast radius, access, rollback — before any risky apply.

Drafts merge-request descriptions covering problem, approach, verification, and risk whenever a branch is ready for review.

Write sub-90-word cold emails and follow-up sequences that earn replies by leading with the prospect's problem.

Design an offer that is easy to say yes to: tiers, price logic, risk reversal, and one obvious default choice.

Audit a project's dependencies for maintenance, license, security, and bloat risk, then rank what to fix first.

Reviews diffs for correctness, risk, and maintainability, returning ranked findings with fixes whenever code needs review before merge.

Prepare images for fast web delivery: pick formats by content, resize to real display sizes, compress, and ship responsive markup.

Compose posters with confident hierarchy: one focal point, a working grid, a disciplined type scale, and load-bearing space.

Runs mobile releases gate by gate — device verification, staged rollout, kill switches — whenever a build heads to the app stores.

Prepare for salary negotiation: triangulated research, three fixed numbers, rehearsed scripts, and a counteroffer decision tree.

Mine usage, billing, and support data for early churn signals, then rank at-risk accounts with transparent reason codes.

Generate name candidates across distinct territories, then filter and score them for clarity, say-ability, and risk.

Audit scattered style values and restructure them into a tiered design token system with strict naming and theming support.

Plan the day as committed blocks: crown one must-move task, protect deep work, buffer every estimate, end with a shutdown ritual.

Draft complete, arithmetic-checked invoices from a plain description of work — line items, terms, and tax flagged, never guessed.

Coach theses and papers with margin-style comments: sharpen the thesis, audit paragraphs, calibrate hedging — authorship stays yours.

Writes commit messages from the actual staged diff — imperative subject, why-first body — whenever changes are ready to commit.

Apply a house style guide rule by rule, logging every edit against its rule and surfacing conflicts instead of freelancing.

Standing rules for AI agents that write code: verify APIs exist, keep diffs small, report uncertainty — for every coding session.

Choose the right chart for each question and lay out dashboards that answer decisions, not decorate meetings.

Design LLM-powered automation pipelines with explicit triggers, checkpoints, human gates, and fail-closed handling.

Build an annual operating budget: bottom-up revenue, costs sorted by behavior, three scenarios, and a cash floor you can see.

Research and write long-form pieces from a claim ledger: triangulated facts, verified quotes, and citations you actually opened.

Write step-by-step SOPs a new hire can run alone: observable steps, explicit branches, exceptions, and an escalation path.

Writes behavior-pinning unit tests with claim-style names and real assertions whenever code, fixes, or gaps need coverage.

Turn discovery notes or RFP requirements into a compliant, skimmable proposal that argues for a decision.

Plans and executes behavior-preserving refactors as small verified moves whenever code needs restructuring without breakage.

Reverse-engineer a brand's voice from samples into a scored sheet, then rewrite copy against it with every change justified.

Drives a real browser through user flows with per-step assertions and evidence whenever UI changes need end-to-end verification.

Build a one-page negotiation brief: targets, walk-away lines, tradeables, counterpart pressures, and scripted hard moments.

Draft employee announcements that lead with the change, say hard things plainly, and tell each audience what it means for them.

Detect the conventions a codebase already follows and write new code that reads like it was always there.

Force-rank a messy backlog with anchored scoring, a capacity cutline, and a written not-doing list everyone can argue with.

Collapses log floods into templated patterns ranked by novelty and growth whenever incidents or noise call for real signal.

Translate contracts into plain English clause by clause, flagging one-sided terms, deadlines, and exit mechanics before signing.

Draft a tight PRD from a problem statement: measurable goals, explicit non-goals, testable requirements, decided edge cases.

Run a structured usability review of any screen or flow, scoring findings by severity with the cheapest credible fix attached.

Hunts a codebase for injection paths, broken authorization, exposed secrets, and unsafe defaults before releases and audits.

Draft a blameless, evidence-anchored incident postmortem with a clean timeline and action items people actually do.

Coach a household budget that sticks: start from real spending, four coarse buckets, sinking funds, and a 20-minute monthly review.

Designs CI pipelines for fast trustworthy verdicts — stage order, caching, flake protocol — whenever builds are slow or noisy.

Break down competitors' live ads into angles, hooks, and offers, then map the whitespace your campaigns can own.

Turn any nontrivial coding request into an approved written plan before the first line of code changes.

Structures the first 30 minutes of a bad deploy: stabilize, build the timeline, localize, then fix forward or roll back on evidence.

Code interview transcripts with a consistent scheme, then surface patterns you can defend with counts and quotes.

Edit machine-flavored prose into writing that reads aloud like a person: cut the tells, vary the rhythm, keep the author's voice.

Write agent skills that trigger reliably and execute consistently: sharp descriptions, concrete steps, testable output.

Turn merged changes into reader-first release notes: benefit-led highlights, symptom-named fixes, breaking changes with migrations.

Audits interfaces by keyboard walk, accessibility tree, and measured contrast whenever UI ships or accessibility bugs surface.

Build time-boxed agendas backwards from the decision that matters, with owners, buffer, and a cut list for what doesn't fit.

Diagnoses broken dev environments by diffing sick machines against healthy ones, then ships prevention whenever setup fails.