Find your next open-source project

Search by name, purpose, or keyword — or paste a GitHub repository URL
All skills

nightly-labs/openbot

Gives local AI agents ready-made skills for coding, review, research, writing and everyday work in a shared desktop workspace.

  • 110 skills
  • 903 stars
  • Reached #3 on GitHub's daily trending

The 5 most installed

Ordered by installs on skills.sh
  • prototype4 installs

    Builds several design directions for a feature as Storybook stories so you can pick one.

  • babysit3 installs

    Works a pull request through the NorbiAI review loop, fixing valid findings and rebutting false positives with evidence.

  • openpanel3 installs

    Queries OpenPanel product analytics and builds or changes dashboards to answer usage and growth questions.

  • Audits a pending release for upgrade and data-loss hazards before the version is bumped or tagged.

  • ship3 installs

    Reviews the diff, opens the pull request, waits for review and CI to pass, then squash-merges to main.

The other 105 skills
  • signal-deploy3 installs

    Checks and deploys the Signal remote-api service to production from a release tag.

  • smoke3 installs

    Starts local dev instances and smoke tests the features a change or pull request adds.

  • triage3 installs

    Checks a GitHub issue or bug report, rates its impact, finds the root cause and fixes it, or pushes back with evidence.

  • Evidence Brief2 installs

    Answers a research question with sourced, dated claims labelled Verified, Reported or Inference, keeping conflicts visible.

  • Meeting Actions2 installs

    Turns meeting notes or a transcript into decisions, commitments with owners and due dates, open questions and conflicts.

  • smoke-and-ship2 installs

    Smoke tests the current branch and merges it to main only when every check passes.

  • Guides how to hand off work to another of your OpenBot agents, read its reply and hold group chats.

  • Account Brief1 installs

    Scores a company against your ideal customer profile using public pages, listing disqualifiers, gaps and discovery questions.

  • Agent Designer1 installs

    Designs and creates a new OpenBot agent by asking a few questions, writing a profile and verifying the result.

  • Build Spec1 installs

    Turns a design frame into a developer-ready spec covering components, spacing, tokens, states, motion and open questions.

  • Compares products or vendors against criteria from your decision, sourcing every cell and marking missing facts unknown.

  • Daily Brief1 installs

    Writes a one-screen morning brief from your calendar, inbox and tasks, with draft replies it never sends.

  • Gives new or heavily redesigned interfaces a deliberate visual direction based on their subject, audience and purpose.

  • Launch Notes1 installs

    Writes release notes from merged work plus a launch checklist with owners and acceptance checks, without publishing.

  • openbot-export1 installs

    Exports your Grok Bot agents into one zip file that OpenBot can import, including skills, routines and memories.

  • Builds, publishes, replaces, lists and deletes small static websites hosted on openbot.site.

  • Project Plan1 installs

    Writes a dated scope document covering goals, exclusions, success measures, risks and owners for approval.

  • Audits all local agents' routines for token waste and helps decide how often each should run.

  • Tracks a recurring operations list in a shared table and writes a weekly digest of overdue, due, done and new items.

  • Tests a live web app against an acceptance checklist in a real browser and reports PASS, FAIL or BLOCKED with screenshots.

  • Audits a web page for keyboard, focus, contrast, headings, forms and motion issues, each rated by severity with a WCAG reference.

  • Reviews recent chats with your local agents to spot friction and suggest new skills, agents or routines from repeated corrections.

  • Writes short, copyable alt text for images, covering decorative images, charts, text images, logos and linked images.

  • Turns an API or repeated workflow into a tested local skill, keeping keys out of files and adding a script only when needed.

  • Sketches types, signatures and module structure before coding, then stays involved while the implementation fills in.

    Runs only when you type /architect

  • Runs several parallel attempts at the same task, picks the best base and grafts in the strongest parts of the others.

    Runs only when you type /arena

  • Drafts or updates a personal skill that captures your preferences and working style so agents follow how you work.

    Runs only when you type /automate-me

  • Checks a performance measurement for limits, repeatability and relevance before you report or act on it.

    Runs only when you type /benchmark-checklist

  • Installs and configures Biome anti-slop lint rules in a local TypeScript or JavaScript repository.

  • Finds what a change could break elsewhere beyond the diff, and proves the safety assumption by running real code.

    Runs only when you type /blast-radius

  • Restates the last message in plain everyday language without jargon.

    Runs only when you type /bro

  • Turns a bug report, logs or failing test into a reproduction, ranked causes, one diagnostic step and the smallest fix.

  • Scores a sales call transcript on seven criteria with timestamped quotes, then gives the top three fixes for next time.

  • Explains what drove a change in campaign results and proposes measurable experiments, keeping observations apart from causal guesses.

  • Keeps a private on-device log of care tasks for plants, pets and appliances, tracking what is due and when.

  • Reviews a code change for bugs, regressions and missing checks, ranking each finding by severity with the smallest fix.

  • Finds mistakes agents keep repeating in a repo and makes each one impossible with architecture, types, lint or tests.

    Runs only when you type /correct

  • Generates a project-local skill that drives your app the way a user does, in any language or platform.

    Runs only when you type /create-verification-skill

  • Sets up a Leaseweb VPS as a customer's own OpenBot server, with that customer as owner.

  • Checks a dataset for duplicates, missing values, units, dates and outliers, and flags which analyses each problem blocks.

  • Adds a short self-check to important recommendations and plans where unverified assumptions could change your decision.

  • Runs first-time onboarding for a newly installed agent designer, setting up its routines and saving your preferences.

  • Designs an auditable playbook for large migrations or multi-part changes, running a hypothesis loop and logging decisions.

    Runs only when you type /figure-it-out

  • Turns role requirements into competencies, interviewer questions, a 1-to-4 scale and an evidence-only debrief.

  • Explains how a subsystem works, its runtime flow and where code should live, before you change anything.

    Runs only when you type /how

  • Reviews a screen from a screenshot, browser page or Figma frame and returns ranked, concrete fixes without editing files.

  • Drafts status reports, leadership updates, announcements, FAQs, newsletters and incident messages for internal audiences.

  • Has multiple AI reviewers challenge a change from independent angles to find blind spots and weak points.

    Runs only when you type /interrogate

  • Summarises everything in the chat since your last message, giving each action item enough context to decide.

    Runs only when you type /ketchup

  • Audits a project's verification skill and feature map, driving every feature live and proposing proven corrections.

    Runs only when you type /maintain-verification-skill

  • Builds a custom page or dashboard that wakes a Grok Bot over a webhook, including the sender key and Tailscale setup.

    Runs only when you type /Make Bot UI

  • Runs a comment-focused review, fixes accepted findings and suggests ways to encode claimed constraints.

    Runs only when you type /no-comments

  • Looks up, updates and counts shared records like people, tasks, messages and results across turns.

  • Creates or revises a reusable local skill when you ask to save a workflow for later.

  • Drafts a first business message built on one verified reason to write, listing claims you must confirm, never sending.

  • Works in a concise, detailed style with deliberate subagents, plain prose, simple code and verified results.

    Runs only when you type /Poteto Mode

  • Answers questions about pstack setup, /poteto-mode, and which skill, playbook or principle fits your task.

    Runs only when you type /poteto-help

  • Tracks a repository's open pull requests, classifies them, fixes failing CI and review threads, and flags ready ones to merge.

  • Checks which actors hold an imbalance before another fix, then questions the shared premise instead of repeating a failed fix.

    Runs only when you type /principle-attack-the-premise

  • Keeps validation and error handling at system boundaries and business logic in pure, trusted internal functions.

    Runs only when you type /principle-boundary-discipline

  • Builds a reusable script, codemod or generator to do or prove the work instead of doing it by hand.

    Runs only when you type /principle-build-the-lever

  • Turns repeated instructions or corrections into a lint, flag, runtime check or script instead of more text.

    Runs only when you type /principle-encode-lessons-in-structure

  • Builds two or three competing prototypes and compares them side by side before committing to a novel UI or architecture choice.

    Runs only when you type /principle-exhaust-the-design-space

  • Favors user delight over implementation convenience when weighing product, UX or feature-scope tradeoffs.

    Runs only when you type /principle-experience-first

  • Checks what limits a measured number and rules out that it measured the wrong thing before you trust or report it.

    Runs only when you type /principle-explain-the-number

  • Traces each debugging symptom to its root cause, reproduces it first, and avoids guards that just silence crashes.

    Runs only when you type /principle-fix-root-causes

  • Gets core types and data structures right before writing logic so downstream code becomes obvious.

    Runs only when you type /principle-foundational-thinking

  • Routes bulky outputs and long files to subagents and keeps only summaries in the main thread.

    Runs only when you type /principle-guard-the-context-window

  • Biases refactoring toward deletion and the smallest change that solves the problem, avoiding extra abstractions.

    Runs only when you type /principle-laziness-protocol

  • Designs commands and processing loops to reach the same end state despite crashes, restarts and retries.

    Runs only when you type /principle-make-operations-idempotent

  • Migrates callers to a new internal API and deletes the old one in the same wave instead of keeping compatibility layers.

    Runs only when you type /principle-migrate-callers-then-delete-legacy-apis

  • Reduces layers and hidden state in hard-to-trace code by collapsing one-caller wrappers and shrinking mutable scope.

    Runs only when you type /principle-minimize-reader-load

  • Models the domain explicitly when writing stateful logic or when code branches heavily or repeats shape assumptions.

    Runs only when you type /principle-model-the-domain

  • Proceeds on reversible work instead of stopping to ask whether it should do something.

    Runs only when you type /principle-never-block-on-the-human

  • Converges planned rewrites and migrations on the target architecture without throwaway compatibility code for smooth intermediate states.

    Runs only when you type /principle-outcome-oriented-execution

  • Verifies against the real artifact, like running the feature or reading the actual value, before declaring a task done.

    Runs only when you type /principle-prove-it-works

  • Rethinks an existing design from first principles when integrating a new requirement.

    Runs only when you type /principle-redesign-from-first-principles

  • Removes shared files, keys or state between concurrent actors first, serializing only when one shared writer is a real invariant.

    Runs only when you type /principle-separate-before-serializing-shared-state

  • Breaks multi-step work into small units that each end in a verifiable state, checking each before the next.

    Runs only when you type /principle-sequence-verifiable-units

  • Removes dead code, redundant validators and stub references before building an addition, refactor or rewrite.

    Runs only when you type /principle-subtract-before-you-add

  • Writes tests that call code as users do and assert exact visible results, rewriting tests that would pass on broken code.

    Runs only when you type /principle-test-behavior-not-implementation

  • Guides the agent to design types that prevent invalid states and validate external data at boundaries.

    Runs only when you type /principle-type-system-discipline

  • Turns an idea into a small clickable static prototype and returns screenshots and a short video.

  • Converts React components, hooks and shadcn patterns into idiomatic SolidJS code.

  • Reconstructs your recent working context and hands back a short brief on where you left off.

    Runs only when you type /recall

  • Records a short video of a change in the real local app and attaches it to the pull request.

  • Finds recurring charges, price changes, expiring credits and upcoming renewals from pasted bank statements.

  • Runs parallel review agents over your session and routes each learning into a concrete skill edit.

    Runs only when you type /reflect

  • Produces a repository-grounded security threat model with assets, boundaries, abuse paths and mitigations.

  • Scores inbound requests against your criteria, turns totals into yes/maybe/no, and drafts replies.

  • Reviews or writes Python, JavaScript, TypeScript or Go code using secure defaults.

  • Configures which models pstack uses per role and at what reasoning budget.

  • Keeps a reviewable log of each decision with reasons and evidence during long unattended work.

    Runs only when you type /show-me-your-work

  • Builds a software spend inventory from bills and finds unused seats, duplicates and cheaper plans.

  • Drafts a customer reply plus an internal note and escalation package, sending only when asked.

  • Fans out many parallel workers on a task and returns a single combined report.

    Runs only when you type /swarm

  • Writes a failing test first and drives the fix, only when TDD is requested or clearly cheap.

    Runs only when you type /tdd

  • Explains a piece of work or a subsystem plainly so you actually understand how it works.

    Runs only when you type /teach

  • Writes and reviews docs, readmes, RFCs, PR descriptions and commit messages to a clear layered style standard.

    Runs only when you type /technical-writing

  • Applies TypeScript best practices whenever it reads or edits .ts or .tsx files.

    Runs only when you type /typescript-best-practices

  • Removes the telltale signs of AI writing from any text.

    Runs only when you type /unslop

  • Rewrites your draft to sound like you, keeping every fact and logging each change with its reason.

  • Researches why a decision was made, pulling cited evidence from code history, issues, docs, chat and analytics.

    Runs only when you type /why

  • Sets up the Zaidan component registry in a SolidJS project and suggests which components fit your interface.