DEDUPED Hot AI repos, turned into use cases Get 5 a day

New this week

3049 use cases added in the last 7 days, newest day first. Also as an RSS feed.

Third-party repos we don't own or vouch for. AI-generated use cases can be wrong: review everything and run at your own risk. Full disclaimer

  • Tailor a CV and cover letter to one job posting

    Paste a posting URL and get a fit evaluation plus a tailored LaTeX CV and cover letter to review.

    View prompt
    In the ai-job-search repo, run /apply on the posting at <posting URL>. Expect a fit evaluation, a tailored LaTeX CV and cover letter, and a reviewer critique with the final revised output. Verify that every claim in the CV and cover letter appears in your own profile files before sending.

  • Pull compound and protein records with source provenance

    Query public biology and chemistry databases and get each record with its source endpoint.

    View prompt
    Using the scientific-agent-skills repo, read skills/database-lookup/SKILL.md and query PubChem, ChEMBL, and UniProt for <target gene or compound list>. Return a table of identifiers and key properties, with the endpoint and access date for each row. Verify that every row names its source endpoint and flag any database that needs a key you do not have.

  • Generate images from ready-made template workflows

    Install the desktop app, open a template, and queue your first image from a visual node graph.

    View prompt
    Using the ComfyUI repo at https://github.com/Comfy-Org/ComfyUI, load the template workflow for <target image type> from comfy.org/workflows, set its prompt to <prompt text>, queue it, and save the result. Expected output: one generated image file and a saved workflow JSON. Verify that the output image opens and matches the prompt.

  • Hand off a half-finished task from Claude Code to Codex

    Quit one coding agent mid-task and resume in another in the same directory with the open questions intact.

    View prompt
    Using the ai-memory repo (github.com/akitaonrails/ai-memory), set up the tool, then start <target-agent> in the project at <project-path> through `ai-memory run`. Expected output: the new agent begins with a brief that lists the last session's status, failed approaches, and open questions. Verify the brief mentions the open questions from the previous session before continuing.

  • Forecast future candlesticks from one price history

    Load a pre-trained Kronos model and get a forecast of future OHLCV candles from your own historical data.

    View prompt
    Using the Kronos repo, load NeoQuasar/Kronos-small with its tokenizer, forecast the next 120 candles for <CSV path with open, high, low, close columns and timestamps>, and return the pred_df table. Verify that the forecast index matches the y_timestamp values you passed in and that the lookback is no more than 512 rows.

  • Map an unfamiliar codebase in one run

    Build a browsable graph and a highlights report for a project you have not worked in before.

    View prompt
    In the Graphify-Labs/graphify repo setup, run `/graphify <repo-path>` on the target repository at <repo-path>. Confirm that graphify-out/ contains graph.html, GRAPH_REPORT.md, and graph.json, then summarize the top concepts listed in GRAPH_REPORT.md.

  • Start the official DSH web runtime in one command

    Launch the official DeepSeek Harness web runtime with npx and manage plugins from Settings.

    View prompt
    In the repo 0xsline/awesome-deepseek-harness, run `npx @deepseek-ai/dsh web` from <project folder>. Report the local address the runtime prints and whether Settings → Plugins is reachable. Verify the command completed without an install error.

  • Give your Hermes agent a spoken voice

    Install the Fish Audio plugin so voice replies and read-aloud use Fish Audio speech.

    View prompt
    Using the repo 100yenadmin/fish-audio-hermes, install the Fish Audio plugin for Hermes Agent on <target machine> and run the setup check with `hermes fish doctor --no-synth`. Expected output: the plugin is enabled and the status check reports no errors. Verify that `hermes fish status` shows Fish Audio as the speech provider.

  • Give an existing agent exact algebra checks via MCP

    Connect ResiMind's five MCP math tools so an agent verifies bounded polynomial algebra.

    View prompt
    Using the ResiMind repo at <repo path>, connect its five MCP math tools to my agent and verify the algebra step in <target expression>. Expected output: an accept or reject verdict for that step. Verify that a deliberately wrong step is rejected before trusting the tool.

  • Give Claude Code bash-style commands on Windows

    Connect Claude Code to Fauxnix so its bash commands run natively on Windows with GNU-style output.

    View prompt
    Using the fauxnix MCP server from the 20000419/fauxnix repo, run `ls -la <target-dir> | head -5` through the bash tool. Expect GNU-style `ls -l` columns and no PowerShell table output, then confirm `fauxnix doctor` reports a successful MCP round trip.

  • Retrieve speaker-labeled evidence from a group chat locally

    Store a multi-person conversation and pull back who said what for a question, with no API key.

    View prompt
    Clone the SpeakerMem-R1 repo (2022hpsk/SpeakerMemR1), set up the virtual environment and install the package as its README describes, then run code/speakermem_pkg/examples/quickstart.py. Report the memory stats and the retrieved entries for the questions 'Who handles evaluation?' and 'What does Bob handle?'. Verify that each retrieved entry shows the speaker name.

  • Check an AI's claims about a binary before trusting them

    Turn an AI's guesses about a binary into VERIFIED or REFUTED verdicts with evidence.

    View prompt
    Using the reverify repo at 2akouwu/reverify, check each claim you made about <target binary> with reverify verify and its --claim JSON format. Report each claim as VERIFIED, REFUTED, or INCONCLUSIVE with the evidence bytes, and do not state any claim as fact unless the tool returned VERIFIED.

  • Stress-test an architecture decision before committing

    Get independent answers, anonymous reviews, and a reasoned recommendation on a design choice.

    View prompt
    Using the a1exsun/dsh-council repo in DSH Web, run /council on this design question: <design question with both options and the failure scenario>. Return the recommended design, its stated assumptions, and the listed disagreements and blind spots. Verify that every assumption appears in the question context and was not invented.

  • Design a typed Jev ticket router in Claude Code

    Install the skill in Claude Code so it writes Jev routing code with typed questions.

    View prompt
    Using the building-with-typesafe-jev skill in this repo, write a Python function that routes a support ticket to billing, shipping, or support using a Jev Choice question. Show the function and the prior-art shape it follows. Verify that the question names the ticket field it reads.

  • Get a morning brief from a bot on a daily schedule

    Set up a bot that drafts your daily brief from connected mail and calendar on a routine.

    View prompt
    Using the AbacusAI Bot desktop app, create a bot from the Morning Brief template for <user's role>, connect Gmail and Google Calendar, and schedule a daily routine. Run it once and report the brief's sections. Verify that the routine run has its own saved output.

  • Reproduce the 25 of 30 LIBERO evaluation result

    Run all 30 LIBERO tasks from the three suites and check the pass count against the README.

    View prompt
    Work in the EvoBot repo at <repo path>. Set up the Python 3.10 environment and PYTHONPATH from the README, then run `bash scripts/verify_30.sh 8 verify`. Report the number of passed tasks out of 30 and list any failed task names. Verify that logs/libero_agent_progress.json has an entry for every task you ran.

  • Resume past Pi coding sessions from a desktop window

    Find earlier Pi sessions by project and continue them without digging through .jsonl files.

    View prompt
    Using the abcwyc/pi-agent-desktop README, explain how to locate and resume a past Pi session for the project at <project-path>. Expected output: the session name and date the user should open. Verify that Pi reads sessions from ~/.pi/agent/ before reporting success.

  • Trace network input to dangerous sinks in a binary

    Find functions reachable from network reads that feed risky command or sink calls.

    View prompt
    In the Ablation repo at ~/ablation, use the Network Sink Finder and Sink Arg Classifier on <binary path>, then trace taint from network sources to each reachable sink. Output a table of sink address, argument class, and taint path. Verify that every listed path has a callgraph edge chain from a recv, read, fgets, or accept call before you report it.

  • Turn a website URL into a launch video

    Paste a site URL into Claude Code and get a rendered 60 fps launch MP4 with sound.

    View prompt
    Using the repo AbubakrChan/product-launch-motion as a Claude Code skill, make a launch video for <target website URL>. Expect a 60 fps MP4 with music and synced sound effects. Verify the file plays with sound and that the first frame matches the last frame of the one-shape sequence.

  • Render a 3D Python scene to a 1080p60 MP4

    Write a Manim-style 3D scene in Python and render it to a 1080p60 MP4 with one command.

    View prompt
    Using the manimgx repo at github.com/academa-labs/manimgx, write a scene.py file with a ThreeDScene subclass that animates <target topic>, then run manimgx render scene.py. Expected output: a 1080p60 MP4 named after the scene class. Verify that the MP4 exists and plays from start to end.

  • Keep one project context across coding agents

    Move between Claude Code, Codex, and Gemini CLI on the same project without re-setting context.

    View prompt
    Using the acryl repo at github.com/acryldev/acryl, set up ACRYL on this machine and open the project at <project-path> as a project. Report the project name shown in ACRYL and list which agents from the roster are available; verify the project appears in the left panel before you finish.

  • Install the Factory into an existing GitHub project

    Add the committed Claude and Codex Factory files to a repo and check the setup with doctor.

    View prompt
    Using the addyosmani/factory repository, install the factory into <target-repo-path> by running install.sh against it. Then run .factory/scripts/doctor.sh inside the target and report every finding. Expected output: a list of remaining setup gaps, or confirmation that none remain. Verify that docs/factory/CHARTER.md exists in the target.

  • Scope an AD assessment in the right phase order

    Use the methodology skills and /ad-scope to plan an authorized internal AD test before any tooling runs.

    View prompt
    Using the Claude-AD repo (ADScanPro/Claude-AD), run /ad-scope for the authorized internal domain <target-domain> and produce a written scope with the phase order and the environment constraints to check. Verify that the scope names the authorized targets and explicitly excludes anything outside the signed authorization.

  • Get a finished file from a plain-language goal

    Describe an outcome in UNIGIT and receive a file you can preview, save, and revise.

    View prompt
    Read the README of adtexterry-lgtm/unigit-ecosystem and list the steps to get a finished <deliverable type> for <goal> using UNIGIT. Expected output: a numbered checklist of workbench steps and the file to be produced. Verify that the checklist only uses features the README names, such as previewing and saving files.

  • Give an existing repo a memory the agent keeps

    Set up Operator on a real project so each new agent session starts from an indexed codebase and written specs.

    View prompt
    Use the Operator Memory repo at https://github.com/aerovato/operator-memory to set up Operator for the project at <project-path>. Run the install steps from its README, then ask the agent to write the first specifications for <module-name>. Verify that a .operator/ directory exists in the project and that it contains at least one specification file.

  • Install ECC as a Claude Code plugin in one guided run

    Get ECC's skills, agents, commands, and hooks into Claude Code without manual file copying.

    View prompt
    On this machine, install the ECC Claude Code plugin from github.com/affaan-m/ECC by running `npx [email protected] setup` with the scope <scope>. Report the output of `/plugin list` and confirm that ecc@ecc is enabled, without adding a manual Claude install.

  • Run your own Comma instance with Docker Compose

    Start a single-node personal agent on your own machine with one compose command.

    View prompt
    Clone the AFK-surf/Comma repository and follow its Self-host with Docker Compose section to start a single-node instance for <owner email>. Report the Web, Admin, and Product API addresses from the Interfaces table and any build errors. Verify that the login code arrives in the local inbox before you finish.

  • Audit local code changes for security problems

    Run the sec specialist on changes since main and get findings with evidence and fixes.

    View prompt
    Use the CodeAF repo at Agent-Field/CodeAF. Install it with its curl script, open the git repository at <project-path>, and run `/sec changes since main` in the chat. Expected output: a security report with findings, evidence and suggested fixes, in Markdown, JSON or SARIF. Verify that the report lists its coverage and any incomplete analysis, and that your source files were not modified.

  • Get a cited answer from a live web page

    Ask a question about a web page and get an answer where each claim quotes the page.

    View prompt
    Use the fastbrowse repo to answer <question> about the page at <start URL>. Run `uvx fastbrowse "<question>" --start <start URL> --json` and return the answer with its quotes. Verify that each factual claim in the answer matches a quote from the page.

  • Run all installed coding agents from one desktop app

    Link the coding-agent CLIs already on your machine and start sessions for each from one place.

    View prompt
    Using the Agent Launcher repo at https://github.com/agent-launch/agent-launcher, detect the coding-agent CLIs already installed on this machine and link them, then start a session for <agent-name> in the project folder <project-path>. Expected output: a list of linked agents and a running session in that folder. Verify that the CLI was not reinstalled or updated.

  • Shortlist self-hosted AI coworkers for a team

    Compare persistent agent platforms by license and hosting before picking one to try.

    View prompt
    Using the awesome-ai-agent-platforms list in the Agenta-AI repo, find the AI coworkers entries marked self-hosted with an MIT or Apache-2.0 license. Return a table of name, license, hosting, and GitHub link for the three best fits for <team goal>. Verify each entry's license note against its GitHub repo before you report it.

  • Deploy a private messaging hub for your agents

    Set up your own Cloudflare-hosted Agent Peer Chat instance and install the shared CLI and skill.

    View prompt
    Deploy AgentPeerChat from https://github.com/AgenticsWorks/AgentPeerChat into my Cloudflare free account, install the CLI and skill, and return the real instance URL. Verify the homepage loads and the API responds, and do not claim success if any step fails; never ask me to paste credentials into chat.

  • Run Nautilo locally on a Mac and make a first document

    Start a private Nautilo on your Mac and write your first document with a Genie.

    View prompt
    Using the agentsea/nautilo repo and its local guide at https://nautilo.ai/docs/operator/deploy/local, walk <user> through a local Nautilo setup on macOS with Docker Desktop and a model API key. Report each step completed and the document created. Verify that Docker Desktop is running before starting.

  • Set up an AI office for your small business

    Install the app, name your business, and start a starter team led by Michael in about an hour.

    View prompt
    Using the repo agentvivekkumar/dontbemichael, download the Mac or Windows build from its latest GitHub release and complete setup for <business name>. Report the starter team members who joined. Verify that Michael is shown in the office and that Get Michael ready reports Claude Code as signed in.

  • Start a nightly journal with Compass daily questions

    Answer ten daily questions and write one journal line each night in an Obsidian vault.

    View prompt
    In the Compass vault at <vault path>, read AGENTS.md and Meta/Compass Config.md, then list the daily question properties (dq_*) and the habit properties (habit_*). Expected output: a short list of the questions and habits, with the folder where today's Daily note is stored. Verify that the lists match the questions in Meta/Compass Config.md.

  • Pause a legal review step for human sign-off

    Park a legal_counsel task for a human reviewer while other DAG branches keep running.

    View prompt
    Use the repo AhmadHassan-BTed/AutoSwarm-Shadow-Adapter with the AutoSwarm session for <target project>. Park the legal_counsel task, then list the pending items in the shadow queue. Expected output: a list of parked tasks with their status and brief. Verify that each parked task shows AWAITING_HUMAN and that no other DAG branch is blocked.

  • Get a GTM diagnosis for your developer tool

    Answer five questions and get one prioritized next move for your go-to-market.

    View prompt
    Install the skills from https://github.com/AIDevGTM/gtm-cofounder and run 00-start-here for <product name>, then run 01-strategy-and-roadmap. Expected output: docs/gtm-cofounder/gtm-roadmap.md with one Now move, a Next list, and a Later list. Verify that the Now move names a specific piece of evidence to collect, not a list of marketing tactics.

  • Draft a tailored resume and cover letter for one posting

    Paste a job posting and get a resume and cover letter built only from your profile facts.

    View prompt
    Using the AienTech/dossier repo, follow its README to start the app with Docker Compose on this machine and open http://localhost:3000. Paste the posting text from <posting URL or file> into New application and report the match summary and the list of gaps. Verify that every resume line traces to a fact in the profile before reporting success.

  • Find out why AI engines never mention your brand

    Sample AI answers, audit the site, and get a gap diagnosis for one brand in about 30 minutes.

    View prompt
    Use the geolook repo at <repo path> to run a full GEO diagnosis for <brand URL>. Report the mention rate, the diagnosis type for each buyer question, and the first-fix order from the four-layer audit. Verify that the dashboard at http://127.0.0.1:8765 loads and that the diagnosis page lists the Access layer result.

  • Fill and submit a web form in your signed-in Chrome

    Have an agent complete a multi-step web form in a background tab using your existing login.

    View prompt
    Using the Chrome Relay repo at aindeev/agent-chrome-relay, run `chrome-relay do` with the goal "<goal>" on <site URL>, passing the values in <data> as --data options and --until "text:<success text>". Report the exit code and the final page text; exit code 2 means hand back to the user with the page state. Verify that the success text appears before reporting done.

  • Build a cut-open pump page for plant operator training

    Turn one line into a single HTML file of a cut-open process pump with curves and break modes.

    View prompt
    Using the repo AirsupHQ/machine-skill, build a cut-open refinery process pump for plant training as one HTML file. The expected output is a single .html file that opens from disk and shows the pump curve, NPSH available against required, and hover labels. Verify that the file opens in a WebGL 2 browser and that the cutaway and break modes respond.

  • Watch every agent project status from one control room

    Install the plugin and bind one conversation to get a live card grid of working, needs-you, and done projects.

    View prompt
    Use the repo Aisland-SJL/dsh-worktable to set up the control room in DeepSeek Harness web at <harness-url>. Report the card grid state for each bound project (working, needs you, or done). Verify that projects with no bound conversation show as idle.

  • Benchmark a self-hosted model on Terminal-Bench 2.1

    Run the Crux agent on 89 Terminal-Bench 2.1 tasks to get a pass@1 score for your own model.

    View prompt
    Use the alanhuangyoo/crux repository. Go to its benchmark folder, run `uv sync`, then run harbor against the terminal-bench/terminal-bench-2-1 dataset with agent crux.pi_agent:CruxPiAgent and model openai/<your-model>. Report the pass@1 score over the full run and the number of tasks evaluated, and confirm the run covered 89 tasks.

  • Check for an existing tool before reverse engineering a device

    Search the index for a product or protocol and clone a maintained tool instead of starting over.

    View prompt
    Use the repo alexgaoth/awesome-reverse-engineered with its re_index.py script to search for <product or protocol>, then show the ranked matches with stars, health and language. Run info on the top match and clone it into vendor/. Verify that the cloned project has a LICENSE file and report its name and license.

  • Cut a launch film for your product from a template

    Turn your product name, prompts, screens and install lines into a scored launch film in four shapes.

    View prompt
    Use the anidoodle repo to create a launch film for <product name>. Fill the launch spec with the product's prompts, screens and install lines, then run launch.mjs ship and return the rendered files for all four shapes. Verify that the ship step reports no cut-off text and passes the audio sync and peak checks.

  • Get Claude Code answers you can skim at a glance

    Install the Attention-kind output style so every answer leads with the conclusion and uses bold and arrows.

    View prompt
    Using the repo alexgreensh/attention-span, install the attention-span plugin in Claude Code, then ask Claude this question: <your question>. Expected output: an answer that opens with the conclusion, uses arrow-marked points and bold key words. Verify that the first line of the reply gives the answer.

  • Turn a SaaS product into a build kit for your team

    Have an agent study a web product in a trial account and hand back a report and a zip for rebuilding it.

    View prompt
    Using the res skill from the alextnetto/res repo, study <product> for the <market> market through the trial browser profile, and do not ask me questions until finished. Expect a re-<product>/ folder with REPORT.html and a handoff zip. Verify that REPORT.html links every rule and barrier ID and that sandbox/ledger.csv lists no writes left unresolved.

  • Render a product demo video from React code

    Install the repo and render the included 16-second demo as an mp4 without a screen recording.

    View prompt
    In the repo Alexwtlf/agentic-product-demo, run `npm install` then `npm run render`. Confirm the output mp4 and poster frame are written to out/ and that the frame gate passes. Report the output file paths.

  • Hand an agent a task card with the graph context

    Turn a piece of work into a board card and give the agent a brief with the dependency facts attached.

    View prompt
    In the Flare board for <project>, call tasks_list for the first lane, then task_get on the card <task id> and carry out the brief it returns. Expected output: a progress note sent with task_update and the card moved to review. Verify that the card now shows the new status in the Tasks panel.

  • Run Claude Code on free models through FCC

    Point Claude Code at a free NVIDIA NIM model and code from your terminal in about 30 minutes.

    View prompt
    Using the repo Alishahryar1/free-claude-code, set up FCC with a NVIDIA NIM key stored as <NVIDIA_NIM_API_KEY>, then start `fcc-claude`. Expected output: Claude Code opens and lists an FCC model in /model. Verify that a simple prompt returns a response before reporting success.

  • Lint Jev questions before sending them to production

    Catch missing options and broken state references in Jev questions before they run.

    View prompt
    Use the wellposed repo (https://github.com/suraj-phanindra/wellposed) to lint the question file at <path-to-question-file>. Fix any missing options or broken state references it reports, then return the corrected file and the linter output. Verify that the linter now reports zero findings.

  • Run a long desktop task from the browser

    Start a multi-step computer task in a web dashboard and keep it running with checkpoints.

    View prompt
    Use the LongHorizon-Harness repo at <repo path>. Start the Dashboard with lh-harness web, create a task for <goal>, and let it run until it reports completion. Expected output: the final reply and the verified state for <goal>. Verify that every round the Auditor accepted is listed as a checkpoint before you report success.

  • Rerun the demo gauntlet to check the evidence yourself

    Run the full gauntlet on the included rate limiter and confirm the reported numbers.

    View prompt
    In the old-coder repo, go to demo-rate-limiter and run ./tools/gauntlet.sh after setting up .venv as the README describes. Report the test count, statement and branch coverage, and planted bugs caught, and state whether each matches evidence.md.

  • Map a step-by-step learning path into AI engineering

    Turn the 18-module course into a dated reading plan you can follow in order.

    View prompt
    Using the README of the repo amitshekhariitbhu/ai-engineering-course, build a module-by-module study plan for <target role>. Output a numbered list of modules in the README order with the lesson count for each, and check that Module 1 and Module 2 appear before any later module.

  • Prepare for an AI system design interview

    Use the guide's framework and interview questions to practice designing AI systems.

    View prompt
    Using the repo amitshekhariitbhu/ai-system-design, read the section How to Solve Any AI System Design Problem and apply its eight steps to the practice problem <target>. Output a one-page design outline with one heading per step. Verify that the Evaluation and Monitoring steps are both present.

  • Learn how LLMs generate text one token at a time

    Work through the Part 1 basics on autoregressive generation and the prefill and decode phases.

    View prompt
    Using the amitshekhariitbhu/llm-inference-engineering repo, read the Part 1 section on <topic> and produce a one-page summary of its key terms. Verify that each term in the summary is defined in the linked Outcome School post.

  • Let Claude Code drive desktop apps with native approvals

    Install LCU as a Claude Code plugin so Claude can use desktop apps after you approve each one.

    View prompt
    Using the amontlabs/lcu repo, install LCU as a Claude Code plugin on this Mac with the marketplace and plugin install commands from the README. Ask me to approve the first app the agent controls, then report the output of /computer-use-apps. Verify that the Approved apps panel lists only the apps I approved.

  • Explain a topic with drawings beside the text

    Get a reply to a how-it-works question with a scheme, chart or table next to the words.

    View prompt
    Using the OpenGhost desktop app from https://github.com/ANDRETRIPOL/OpenGhost, ask the agent to explain <topic> with drawings. Expected output: a reply that includes at least one drawing beside the text. Verify that the drawing responds to pointer input and can be edited.

  • Turn a vague coding request into a checked spec

    Convert a one-line request into an IntentSpec that the repo partly answers and you answer once.

    View prompt
    Using the Intent-Router skill in this repo, turn the request '<request>' into a typed IntentSpec. Probe the repo first and ask only the one question the repo cannot answer. Expected output: a saved IntentSpec file under .intent/ with evidence pointers and a state field. Verify that no probed field lacks an evidence pointer.

  • Audit an app feature gate for CWE-602 authorization flaws

    Decide whether a client-side premium or feature check is local or enforced by the server.

    View prompt
    Using the Seep Reverse Lab workspace, audit the premium check in <path-to-apk> for CWE-602 authorization issues, but only for the app I am authorized to test. Expected output: a short report that says whether the gate is local or server-authoritative, with the evidence. Verify that the airplane-mode confirmation was run and recorded.

  • Explore an unfamiliar codebase without risking edits

    Use the read-only plan agent to map a new repo and plan changes before touching any files.

    View prompt
    Using the OpenCode repo at anomalyco/opencode, start the plan agent in <project-path> and ask it to summarize the code structure and list the files that would need changes for <task>. Expected output: a structured summary plus a numbered change plan. Verify that no files were edited, since the plan agent denies file edits by default.

  • Route support tickets with a hosted decision API

    Send a ticket and your label set to a hosted decision model and get a probability for each label.

    View prompt
    Using the Hosted APIs section of github.com/AnotiaWang/awesome-decision-models, pick one hosted decision model and call its /v1/systemone endpoint with the ticket text in <ticket-file> and these Choice options: billing, bug, account, other. Expected output: one probability per option that sums to about 1. Verify that the response contains a probability for every option you sent.

  • Turn a casual clip into a 24-view orbit set

    Generate 24 consistent target-view videos of one person from a single monocular video.

    View prompt
    In the 4DAnyone repo, replace the example video path with <video_path> and run inference.py with --views_per_layer 24 writing to <output_dir>. Expected output: cameras.json, skeletons/, and videos/ with 24 target videos. Verify that cameras.json lists 24 views and videos/ contains 24 .mp4 files.

  • Evolve an agent skill directory against your eval set

    Let agents rewrite SKILL.md, references and scripts until an evaluator scores the agent higher.

    View prompt
    Using the AntOmniEvo repo (ant-research/AntOmniEvo), set up an evolution run for the skill directory at <skill-dir> with an Evaluator that scores outputs from 0 to 1. Expected output: the best candidate's tunable artifacts as a directory plus its change lineage. Verify that the CandidateStore holds every candidate, run, analysis, and changelog.

  • Review a sample LEGO model with previews and BOMs

    Run the bridge example through review and get PNG previews, a validation report and parts lists.

    View prompt
    In the ldraw-nova repository, run ./ldraw-agent doctor, then ./ldraw-agent review examples/bridge.plan.json --outdir output/bridge-review. Report the artifacts written to output/bridge-review and summarise any warnings or skipped checks in the validation report. Verify that the Python BOM and the LeoCAD BOM comparison both exist before reporting success.

  • Explain complex code in an unfamiliar project

    Ask Claude Code in your terminal to explain how a part of an unfamiliar codebase works.

    View prompt
    Use Claude Code in the anthropics/claude-code-style workflow: open the project at <project-path> in the terminal, run `claude`, and ask it to explain how <module-or-feature> works, including the files it depends on. Expected output: a short written explanation naming those files. Verify by opening one named file and confirming the described function or flow appears there.

  • Install a vetted plugin from the official marketplace

    Add a ready-made Claude Code plugin from the official directory in one command.

    View prompt
    Using the anthropics/claude-plugins-official repo, install the plugin <plugin-name> with `/plugin install <plugin-name>@claude-plugins-official` in Claude Code. Report the install result and the plugin's homepage URL. Verify the plugin appears under `/plugin` before reporting success.

  • Run a Claude customer support agent over a knowledge base

    Get an AI support agent that answers customer questions from a knowledge base, as a starting point to customize.

    View prompt
    Work in the anthropics/claude-quickstarts repository. Open the customer-support-agent quickstart, follow its README to install dependencies and set the Claude API key, then start the app. Report the URL or command used to run it and the answer to one sample customer question, and confirm the answer draws on the knowledge base rather than generic text.

  • Have an agent verify the book's code citations

    Use an AI agent to check each file:line quote in a chapter against the pi source at the stated commit.

    View prompt
    In the antinomie-lab/pi-book repo, open <chapter-file> under agent/. For every file:line reference and its quoted excerpt, open <pi-repo-path> at commit cd20a8d2e and check that the excerpt matches the cited lines. Output a table with each reference, MATCH or MISMATCH, and the actual text if it differs; verify that the count of references equals the count you found in the chapter.

  • Explain a Blender scene before changing anything

    Ask the assistant to read object structure and describe a scene before any edits are made.

    View prompt
    Using the mcp-for-blender-pro add-on running in Blender, call the scene inspection tools (get_scene_info, list_objects, get_object_info) on <scene name or file>. Return a plain-language summary of the object hierarchy and parent relationships. Verify that no object was created, moved, or deleted during the run.

  • Inspect a Blender scene before the AI changes it

    Ask the built-in assistant to explain a scene's object structure before any edits are made.

    View prompt
    Using the mcp-for-blender-pro add-on in Blender, ask the built-in assistant to inspect <scene name> and explain its object structure without making changes. Expected output: a written summary of objects, hierarchy and layout. Verify that no objects were added, moved or deleted by comparing the object list before and after.

  • Take over an existing codebase with an agent in one pass

    Build a Git-versioned index of a codebase of up to about 500,000 lines so the agent can start working from known context.

    View prompt
    In the repo <project-path>, confirm the AOCI MCP server is connected, then build the AOCI index for the whole project. Report the coverage level for each area and give me the AOCI panel link. Verify that aoci.txt and aoci.code.txt exist after the build.

  • Run a private companion that remembers your details

    Install the desktop companion, add a provider key, and keep memories on your own machine.

    View prompt
    Using the Apeireth repo at <repo path>, confirm the companion starts on <target machine> and answers a test message. Expected output: a reply in the chat window. Verify that the memory section in Settings lists the test message.

  • Research a question with a parallel agent team

    A coordinator splits a broad question into parallel sub-agent tasks and returns one synthesized report.

    View prompt
    Using the FrontierAgent repo at <repo path>, run agent_team mode with --cwd set to <project path> and the question <question>. The expected output is a final report plus deliverables in the run's /outputs folder. Verify that the report cites evidence the sub-agents collected and that the run directory contains the checkpoint and trace.

  • Build a mobile app's screens from top-grossing patterns

    Have an agent study top-grossing apps in a category, then build the screens for your new app to a simulator-checked bar.

    View prompt
    Using the appllama/appllama-skills repo, study the top-grossing apps in the <category> category through the Appllama MCP, then build the core screens of <app idea> in Expo / React Native. Output the screen list and simulator recordings, and verify that each screen was checked in the simulator before you report it done.

  • Check a web settings form saves correctly, offline

    Fill and save a settings form in a local browser run, then confirm the saved message and page state.

    View prompt
    Use the fast-browser-use repo at <repo path> to fill and save the settings form at <form URL> with the values in <values file>. Return the execution trace and whether the saved confirmation text matches <expected text>. Verify the page with the --expect-text assertion before reporting success.

  • Run a free open model as an endpoint for Claude Code

    Start a Kaggle notebook, copy the public URL and key, and point Claude Code at an open model.

    View prompt
    In the ARahim3/kaggle-tpu-lab repo, open the Qwen3.8-27B notebook from the model table, run it on Kaggle, and copy the printed URL and API key into ANTHROPIC_BASE_URL and ANTHROPIC_AUTH_TOKEN, with ANTHROPIC_MODEL set to <model>. Expected output: a Claude Code reply to a test prompt from the open model. Verify that the endpoint answers before reporting success.

  • Iterate on a plugin without restarting the host

    Edit a TypeScript plugin and see the running host reload it on every file change.

    View prompt
    Using the repo arcships/rutis, create a TypeScript plugin named <target> with `npx @arcships/rutis-host new <target> --lang node`, install it, and start it with `npx rutis-host dev`. Expected output: the host running the plugin and logging a reload after you change a file. Verify that the reload happens without restarting the host process.

  • Build a design system from your existing app UI

    Turn the screens your app already ships into tokens, components, docs and checks.

    View prompt
    In the arla6ka/design.how skills installed in this repo, run design-system-boss on <target app path>. Report the tokens, canonical components, docs and CI check it creates, plus the run branch name. Verify that no commit landed on the default branch.

  • Pair your phone to agents on your computer

    Install Pairfob once, scan a QR code, and open live agent sessions on your phone.

    View prompt
    In the arronKler/pairfob repo, follow the Quick start in README.md to install Pairfob and run `pairfob pair` on this computer. Report the output of `pairfob list` showing one paired device. Verify that `pairfob` prints a running status before you finish.

  • Summarize a YouTube video from its transcript

    Get the spoken text of one video and pull a summary or quotes from it.

    View prompt
    Using the youtube-skills repo, fetch the transcript of <video URL> with timestamps and write a five-bullet summary plus three quotes with their timestamps. Verify that each quote appears in the returned transcript text before you output it.

  • Benchmark a local model server you already run

    Point the tool at a running OpenAI-compatible server and get tokens per second and latency numbers.

    View prompt
    Using the agentperf-local repo from ArtificialAnalysis, run `agentperf-local run` against the OpenAI-compatible server at <base-url> serving model <model-name>, writing output to results/<name>. Confirm that summary.json exists and report output tokens per second and median and p95 turn times. Verify the run is not marked reduced before you report it as comparable.

  • Turn a system description into an interactive architecture diagram

    Describe a request flow in plain words and get one HTML file that teammates can hover, click and walk through.

    View prompt
    Use the SeeCode skill from the Aryanutkarsh/SeeCode repo to diagram <describe the target system flow>. Produce one interactive HTML file that shows each component and its connections. Verify that every component named in the description appears as a node and that the file opens in a browser.

  • Evolve an agent's skills from its own task traces

    Run the full WikiSkill loop so the agent distills failures into a wiki and gates skill changes.

    View prompt
    Use the ashutoshsinghpr7/wikiskill repo to create a demo workspace with `wikiskill init demo`, then run `wikiskill evolve --iters 3`. Report the baseline score from `wikiskill status` and whether each proposal was kept or rolled back. Verify that the wiki folder still contains its pattern pages after the run.

  • Stop your dsh agent from forgetting you between sessions

    Install the plugin so facts you tell the agent are kept and recalled in new sessions.

    View prompt
    Use the dsh-auto-memory repo to store the fact "<fact to remember>" as a memory for the DeepSeek Harness profile demo. Then start a new session and ask the agent what it knows about the topic. Expected output: the agent quotes the stored fact in the new session. Verify that a Markdown file for the memory exists under $DSH_HOME/memory/.

  • Build a 12-lesson audio course on any topic

    Turn a topic you name into about 12 two-minute audio lessons with cards and cited sources.

    View prompt
    Using the Claudemy skill in the assafkip/claudemy repo, ask Claude Code to teach <topic>. Expected output: about 12 two-minute MP3 lessons, a card per lesson, and a playbook file in the local workspace. Verify that each lesson card links to the pages the research actually read.

  • Watch your agent sessions as a live team call

    Open a live animated call that shows which Claude Code or Codex agent is working and who is waiting on whom.

    View prompt
    In the repo Atoll92/agent-standup, run `npx @double_geste/agent-standup@latest --open` and open the live call for my newest Claude Code or Codex session. Report which agents are shown as working and which are waiting. Verify that the sub-agent tree lists the lead and its sub-agents with their status.

  • See every AI agent and MCP server on a machine

    Run one read-only scan to list each agent, MCP server, and AI extension and what it can reach.

    View prompt
    Run `npx geiger-scan` in the terminal on the machine <machine name> and return the list of findings with their capability labels and evidence paths. Verify that the output reports zero write operations other than any file you named, and that no credential values appear in the output.

  • Run Codex CLI on Atria Dawn as a text-only agent

    Point Codex at the Atria endpoint and stop it from sending images to the model.

    View prompt
    Using the atria-asi/Atria-Dawn README, configure Codex CLI to use the model Atria-Dawn through the provider at https://api.atria-asi.ai/v1 with text-only input. Write ~/.codex/atria-catalog.json and update ~/.codex/config.toml as described. Expected output: a Codex session that answers a text prompt without a 400 error. Verify that the catalog lists Atria-Dawn with input_modalities set to text.

  • Run coding agents on several machines in one window

    Link a laptop and a GPU box so Claude Code and Codex run in one command center.

    View prompt
    In the openharness repo at autonomous-ai/openharness, follow the Get started section to link the machine <machine-name> to the desktop app. Confirm that the daemon runs with `harness start` and that <machine-name> appears under Machines. Report the machine name and the list of harnesses running on it.

  • Pick up a Claude Code project where you stopped

    Get Claude to recap your last decisions and open threads when you return to a repo.

    View prompt
    In the repo <repo-path> with claude-db installed, run /catchup in Claude Code and report the decisions, dead ends and open items it lists. Verify that each item matches a real earlier discussion or commit in the project before you rely on it.

  • Stop Claude Code from repeating past decisions and dead ends

    Save decisions, rules and failed approaches from Claude Code chats and reuse them next session.

    View prompt
    In the jevmem repo's setup for <project-folder>, run the jevmem setup flow and confirm that JEVMEM.md exists in the project root. Expected output: a JEVMEM.md file with at least one line tagged as a decision, rule or dead end after a short test chat. Verify by running `jevmem doctor` and checking that it reports no missing setup steps.

  • Dry-run a goal to see the next step before any clicks

    Preview what the agent would do for one plain-English goal without touching your mouse or keyboard.

    View prompt
    In the typesafe-computer-use repo, run `uv run clicker "<goal>"` with no --act flag so it performs a dry run of one step. Report the action it would take and the reason it printed. Verify that no mouse or keyboard event was sent by checking that the command exited without the --act flag set.

  • Trace the exact call path between two functions

    Show every hop from a caller to a target function, with source lines, before you change code.

    View prompt
    In the <repo> project, run `axiomcode path <caller> <target>` to list the call chain from <caller> to <target>. Report each hop with its file and line. Verify that every hop is marked resolved or one of a set, and say which hops are candidates rather than confirmed.

  • Gate agent commits so bad changes never land

    Run the commit gate on agent output to catch formatting, conflict markers, junk files, and secrets.

    View prompt
    In the azrtydxb/procoder-enabled repository at <repo-path>, run `procoder check` after your changes. Report the count of blocking findings and fix each one before you commit. Verify that the final run shows zero blocking findings.

  • Study a from-scratch causal Transformer in PyTorch

    Read and test an explicit GPT-style decoder built without pretrained weights or the Hugging Face Trainer.

    View prompt
    Clone https://github.com/BaruqueRodrigues/llm-legislativo and explain how the causal attention and the gradient accumulation loss are implemented in src/legislm/model/ and src/legislm/training/. Output a short summary with file paths and line references. Verify each claim by reading the code, and say so if a file is missing.

  • Turn an app idea into a clickable multi-screen prototype

    Describe an app and get linked HTML screens you can click through and export as one offline file.

    View prompt
    In the Quilt repo at <repo-path>, start the packaged app and generate a main flow for this app idea: <app-idea>. Report the screen names from the app map and list any broken links. Verify that the export produces one HTML file that opens without a server.

  • Edit local clips into an MP4 without an API key

    Import local video, audio, and images, arrange them on a timeline, and export an MP4 in the browser.

    View prompt
    Use the BeatDesign repo at <repo path>. Start it with pnpm dev, import the local clips in <clip folder> into the Video Editor, arrange them in order, and export an MP4. Verify that the exported file plays in a browser.

  • Make a beat-synced launch video from a script

    An agent turns a release script into a 1920×1080 video with voice-over, captions and music.

    View prompt
    Using the motion-video skill from bestagentkits/motion-video-skill, make a <length>-second launch video for <release name> in the comic multiverse style with voice-over, captions and music. Follow the production pipeline in order and deliver the rendered 1920×1080 30 fps video. Verify that hyperframes lint and check pass and that the loudness is around -14 LUFS with a true peak no higher than -1 dBFS.

  • Plan a first KDP book from an income goal

    Turn a monthly profit target into a researched niche, book idea and small first experiment.

    View prompt
    Use the Beyondwords skill from the repo beyondtahir/beyondwords. My target is <monthly profit goal>, budget <budget>, and I have <hours per week> hours per week. Return the goal summary, five researched niches with one book idea each, and a costed first experiment. Verify that the experiment states its budget and workload and does not promise earnings.

  • Find the symbols behind a bug question before editing

    Ask a plain bug question and get the ranked code symbols that answer it.

    View prompt
    Using the bgts-context-engine repository, index the repository at <target repo path> with bce index, then run bce context with the bug description <bug description> as the task. Expected output: a ranked list of symbols with a coverage report. Verify that the top results include the function that sets the behaviour named in the bug.

  • Translate a screenshot or photo without OCR

    Get the translated text from an image in one command, with no separate OCR step.

    View prompt
    Use the repo at https://github.com/bilibili/Index-Translate. Run `python inference/llm/call_api.py --image <image_path> --target <language_code>` on the image at <image_path> and return the translated text. Verify that the output is in the target language and that it covers the main text visible in the image.

  • Reproduce a BEHAVIOR task mean Q-score

    Run the five fixed BEHAVIOR instances for one task and compare the mean with the reference value.

    View prompt
    In the RoboHarness repo, run the task <task id from ./run.sh --list> with --dry-run first, then the full five-instance run into a new run directory, then generate the validation report. Report the task mean from runs/<run>/summary.json and whether --require-match passed. Verify that all five instance IDs are 301, 304, 306, 308 and 310 before you start.

  • Turn a picture into a rigged, animated game character

    Go from one picture or sentence to a textured humanoid with a skeleton and a chosen move, exported as GLB.

    View prompt
    Using the AssetFurnace repo at <install folder>, make a rigged humanoid from the picture at <picture path>, apply the walk move, and export the animated GLB. Verify that the output file is a GLB that contains a skeleton and an animation track.

  • Find where Claude Code tokens are wasted

    Run one report on your local logs to see savings ranked by how sure they are, in dollars.

    View prompt
    Run `npx optimaizr` from the optimaizr repo (github.com/blendbunjaku/optimaizr) on this machine and report the Clear waste and Re-reading the conversation figures. Verify that the savings are reported per month and that the three savings tiers are not added together.

  • Build a cinematic 3D landing page from a brief

    Turn a one-page brief into a scroll-driven 3D product site using the Dioramas engine.

    View prompt
    Work in the blendi-remade/dioramas repo. Read docs/ENGINE.md and the brief at <path-to-brief>, then build a new example site under examples/ for <product name> with one signature interaction. Expected output: an examples/<slug>/ folder with index.html, main.js and style.css that loads at /examples/<slug>/ on the dev server. Verify by running npm run dev and confirming the new page renders without console errors.

  • Delegate a background code investigation to an Agent

    Hand a bounded read-only question to a background Agent while the Lead session stays free.

    View prompt
    Using the pi-herdsman repo, install the stack and ask a scout Agent to inspect <feature area> in <project path>. Expected output: a written summary of the flow from the scout Agent while the Lead session accepts other prompts. Verify that /agents lists the scout Agent while it runs.

  • Deploy a working AI chat app with your own model key

    Click one deploy button, paste one API key, and get a live AI chat site from this repo.

    View prompt
    Using the repo BoardUI/boardui, guide me through its Vercel deploy button and the AI_API_KEY variable, using <provider-name> as my provider. Expected output: a live URL where the homepage chat returns a reply. Verify that the key is set only as a server-side environment variable and that a spending limit was created where the provider offers one.

  • Turn chosen WeChat chats into cited personal notes

    Have a coding agent write a private wiki from your chats, with each fact tied to its source message.

    View prompt
    Use the GreenBubbles personal-memory skill in the repo bojieli/greenbubbles at <skill path>. Read chats from the last month through the greenbubbles CLI and write Markdown notes, one article per life topic, with each fact citing its source message. Verify that every note fact has a citation and that no passwords or keys appear in the output.

  • Model a parametric part in a local PartMode browser

    Run PartMode on your own machine and build a constrained, editable 3D part in the browser.

    View prompt
    In the BOMWiki/partmode repository, follow the local run steps in the README to start PartMode on http://127.0.0.1:4401, then report the URL that responds and the name of the template you opened. Verify that the server prints no build errors before reporting success.

  • Validate a fresh BootLoops clone before trusting it

    Run the validation command to confirm the toolkit packages pass their own batteries on your machine.

    View prompt
    In the bootloops repository, install the core Python dependencies, then run `python3 run_selftests.py --par 8`. Report how many packages come back green, which 3 stop with a named error, and what each error says is missing. Verify that no failure is caused by a Python version below 3.12.

  • Approve Codex and Claude Code requests from your phone

    Pair your computer with your phone so you can approve commands and answer agent questions away from your desk.

    View prompt
    Using the BotBus setup described in botbus-io/botbus-protocol, confirm that the Mac app is paired with <phone name>. Report whether a Codex or Claude Code task on <computer name> is waiting for a request, and list the request kind and task ID without approving anything.

  • Run cited deep research and turn it into a report

    Install super-research and spark-report so your agent researches a question and writes a cited page.

    View prompt
    Using the genspark-claw repo at github.com/breakstageaxe61/genspark-claw, install the super-research and spark-report skills into <target-runtime> and run super-research on the question: <research-question>. Expected output: a cited report with an executive summary, inline citations, and next steps produced via spark-report. Verify that every claim in the report has a citation before reporting success.

  • Run Claude Code on one project inside a sandbox

    Start Claude Code in a microVM that can only see the project folder you name.

    View prompt
    Using the brig-sh/brig repository, install Brig on this Mac and run `brig doctor` to check the host. Then start a sandbox with `brig run claude <project path>` and report the output of brig doctor and whether the sandbox started. Verify that the project path is the only folder the README says is mounted at /work.

  • Let a coding agent operate a running Mac app

    Give an agent read and click access to a Mac app window, one shell command per step.

    View prompt
    Using the macos-harness repo at https://github.com/browser-use/macos-harness, run `macos-harness get_app_state --app <app name>` on the target app and list the numbered elements in its window. Verify that the output contains at least one numbered element and a screenshot path before you click anything.

  • Draw a flowchart or architecture diagram as lint-clean SVG

    Have your agent hand-place an SVG diagram in the house style and confirm it with svg-lint.

    View prompt
    Using the svg-diagram skill from bybit-exchange/svg-diagram, draw an architecture diagram of <system> as diagram.svg. Run node tools/svg-lint/bin/svg-lint.mjs diagram.svg and fix every finding until it reports 0 errors and 0 warnings.

  • Hand off a full Claude Code session to a fresh chat

    Automatically write a summary, clear a nearly full conversation and continue in a new one with the work intact.

    View prompt
    In Claude Code, install the ctx-handoff-mod plugin from cablate/ctx-handoff-mod, then turn on auto_handoff in the /handoff panel Settings tab for <project path>. Expected output: `/handoff` prints a context line with a threshold of 600000. Verify that the setting shows as on before the session ends.

  • Build a real-footage documentary montage for free

    Have an agent assemble a real-footage montage from free archives and stock with music and no narration.

    View prompt
    Use the OpenMontage repo at <repo-path> to make a 75-second real-footage montage about <topic> with no narration and an elegiac tone. Read AGENT_GUIDE.md, pick the matching pipeline, and render an MP4. Verify the output with ffprobe that it is about 75 seconds long and has an audio track.

  • Run an Expo app in a simulator beside your chat

    Install Mobile Dev, pick a simulator, and have Codex build and run your app in view.

    View prompt
    Using the callstackincubator/codex-mobile-dev-plugin Mobile Dev plugin, build and run the Expo app at <project path> on the simulator named <device name>. Expected output: the app launches on that simulator and is visible beside the chat. Verify the device panel shows the running app before reporting success.

  • Build a RAG question-answering prototype with a golden set

    Build retrieval-augmented answers from raw API calls, then score them against a golden set.

    View prompt
    Using the repo calmrocks/ai-engineer-notebooks, work through 03-rag/00-what-is-rag.ipynb and 04-evals/01-golden-sets.ipynb against the documents in <placeholder folder>. Report the golden-set pass rate and list the three questions that failed. Verify that each failed answer is checked against the retrieved passages, not only the final text.

  • Run Claude Code or Codex on a model you own

    Launch Claude Code or Codex so the model answers on your Mac instead of a vendor server.

    View prompt
    In the canivel/dynolab repo, read docs/coding-tools.md and launch Claude Code on the downloaded model <model-name> with `dyno launch claude --model <model-name>`. Expected output: a Claude Code session that answers a simple prompt using the model served on this Mac. Verify that the session replies and that the model is the one you started in Dyno Models.

  • Refine small faces in a MiniMax H3 video

    Track each face per frame, crop to it, re-generate it with H3, and stitch it back into the clip.

    View prompt
    Using the repo Carasibana/ComfyUI-H3-FaceRefine, build a ComfyUI graph that refines the small face of <subject description> in <video path> and writes a composited video to <output path>. Verify that the tracker report shows the subject found on most frames and lists any lost frame ranges.

  • Chat with a large model offline on your Mac

    Install Slotstream and get a first offline reply from a 125B model on a 16 to 64 GB Mac.

    View prompt
    In the carloslfu/slotstream repo, install the tool, run `slotstream doctor`, and then run `slotstream run --prompt "<your question>"`. Expected output: a text reply from the local model. Verify that the reply prints after the model download finishes and that no cloud service is contacted.

  • Review a design for threats before building it

    Load the security threat-modeling skill to find assets, entry points, and trust boundaries in a planned design.

    View prompt
    Using the cbrock84/headcount repo, load the security:threat-modeling skill and run it against the design in <design-doc-path>. Expected output: a list of assets, entry points, trust boundaries, and controls for that design. Verify that every trust boundary named in the output appears in the design doc.

  • Check PDF-extracted Chinese text for look-alike glyphs

    Find Kangxi and radical look-alike characters in extracted text and fail an ingest run on them.

    View prompt
    Using the cjkfold repo, run `pip install cjkfold`, then run `cjkfold check <path-to-extracted-text-file>`. Report the number of look-alike characters and list the first three with their line and column. Verify by running `cjkfold fold -w` on a copy of the file and then `cjkfold check` on that copy, which should exit with code 0.

  • Run the offline research sample and open its workbench

    Start the local app on bundled fixtures and inspect the staged research workbench without any external services.

    View prompt
    In the finathink repo, set up the environment as described in its Quick Start, then run the local app with --sample on port 8765. Report the /workbench stage list, each stage status, and the manifest fingerprint shown. Verify that the sample run reports the stages from the research flow without requiring any external credentials.

  • Ask JEV a color question about each object in a photo

    Detect objects in one image and get a per-object color answer from a fixed list of options.

    View prompt
    In the JEV_sees repo at <repo path>, with TYPESAFE_API_KEY set, run examples/bus_color.py and report the printed rows for assets/bus.jpg. Expect a table with object_id, label, choice, and confidence columns; verify that each choice is one of the listed colors.

  • Ask your coding agent questions from inside WoW

    Run the bridge, then send a task from the game and get pinged when the agent replies.

    View prompt
    In the wow-ai repo, follow the README install steps for your OS with the project path <project-folder>, start the bridge with npm start, then confirm the bridge light is green in the WoW window. Expected output: a short reply from the agent appearing in the game chat. Verify the reply arrived in the window before reporting success.

  • Read a long paper from overview to full text

    Paste an arXiv or PubMed Central link and read the paper one level at a time.

    View prompt
    Using the TextFold repo at github.com/chenxiachan/textfold, run `python3 -m textfold get <paper-link> --level key --section 3` to get the key points of section 3 of the paper. Expected output: the points of that section, each with its reason. Verify that every point is marked as model-written and points back to the author's sentences it rests on.

  • Keep several accounts in separate browser identities

    Give each account its own fingerprint, cookies, proxy and timezone so sessions never mix.

    View prompt
    Using the repo chienbm98/foxprofile, set up one profile for the account <account-name> with the proxy <proxy-host:port> and locale <locale such as vi-VN>. Report the profile name, engine and emulated device shown in the profile table. Verify that the profile table lists the new profile with its proxy hidden and the chosen locale.

  • Keep a long Codex image task going by unchecking old images

    Uncheck past images in the Context Assets panel so later requests stay small and the task keeps running.

    View prompt
    Using the repo chipfighter/context-attachment-manager, install the plugin in the Codex desktop app for the task <task name>, then uncheck the images from turns older than <turn number> in the Context Assets panel. Report the estimated size of the next request shown in the savings card, and confirm that the unchecked images appear as placeholders in the next message.

  • Run DeepSeek Harness in a desktop window

    Install the desktop app and start a Harness coding session with no Node.js or terminal setup.

    View prompt
    Using the chokwinlee/deepseek-harness-desktop repo, guide me through installing DSH Desktop on <my operating system> and starting a Harness session in the workspace <workspace folder>. Expected output: a running session with the sidebar showing a DSH Desktop version and a Harness version. Verify that the Harness version label appears before you finish.

  • Make an NPC in your own game answer you in character

    Install the skills, stand up the voice server and get one NPC replying in a cloned voice.

    View prompt
    Using the NPCTalk repo at https://github.com/christos-antono/NPCTalk, start the make-npcs-talk skill and make the NPC <npc-name> in <game-name> answer typed questions in a voice. Expected output: a working speak loop and a WAV from `npctalk say`. Verify that `npctalk health` reports the voice server up before testing the game.

  • Compare products for a shopping brief

    Get ranked product choices with reasons, rejected offers, and sources from your AI app.

    View prompt
    Use the NorthCinder MCP server to search for <product request> and compare price, delivery, fit, and merchant trust. Return up to three ranked choices with the reason for each rank, the rejected offers, and any facts that could not be verified. Verify that each choice lists the store it came from and that no purchase was started.

  • Scaffold a research agent from the quickstart template

    Generate a working Tardigrade agent project and adapt its atoms to your own task.

    View prompt
    Using the repo clavia-labs/tardigrade, run `bunx tardie init meeseeks --template quickstart` in a new directory named <project-name>, then change the role atom to describe <target research task>. Expected output: a project with an actor defined by defineActor that uses atom, codeMode, compact and infer. Verify that the actor file imports from tardie/core and tardie/agent.

  • Rank a shortlist by weighted criteria in CI

    Score each item on weighted dimensions from a YAML spec and gate builds on the result.

    View prompt
    Use the jeff-cli project at github.com/saembit/jeff-cli with a YAML spec for <target candidates>. Run its noul or score command and report the ranked list and any threshold failures as exit codes. Verify that three items match a manual check of the spec weights.

  • Run a private model server on your PS5

    Load a GGUF model on the PS5 GPU and use it from any device on your home network.

    View prompt
    Using the cobanov/PS5LM repo, help the user set up a model server on a PS5 at <PS5-IP>. Send a chat request to http://<PS5-IP>:8081/v1/chat/completions with any model name and confirm a non-empty reply comes back.

  • Run a coding task from one sentence to a reviewed change

    Start a task from one prompt and approve the spec and diff at a human gate.

    View prompt
    Using the Grasp repo (cocofhu/grasp), start a run for <task description> from the home page of a local Grasp instance. Confirm the run reaches the human gate, then report the spec and the code diff summary the reviewer will see.

  • Stop a coding agent from breaking your written project rules

    Hook Abide into your agent so each edit is checked against your instruction files and violations are repaired in the same turn.

    View prompt
    In the repo <repo-path>, install Abide with `npx @coldtea/abide init` and confirm that `.abide/rubric.json` was created after the first agent turn. Then ask the agent for an edit that breaks one rule in AGENTS.md and report the rule id and file that Abide names.

  • Compare refusal behavior with and without ablation

    Run one prompt at alpha 0 and alpha 1 on the same weights to isolate the intervention's effect.

    View prompt
    Using the repo Continuum-AI-Corp/OrcaBonsai-27B-Uncensored, run run.py with --pack set to <pack-path> and the same prompt at --alpha 0 and then --alpha 1. Expected output: two replies to the same prompt, shown side by side. Verify that both runs used the identical --pack path.

  • Find the exact step that broke an agent run

    Replay a failed coding agent run offline and see which tool call changed a file or skipped a failing check.

    View prompt
    Use the OrcaReplay repo (Continuum-AI-Corp/OrcaReplay) to inspect the most recent failed run on this machine by running `orca show last` and `orca graph last`. Report the sequence number of the tool call that changed <target file> and the sequence number of any shell check that exited non-zero. Verify that `orca replay last` prints the run again with no model called.

  • Run your own agent service and try an agent

    Start a self-hosted agent service with Docker Compose and send a first message.

    View prompt
    In the agent-foundation repo (converge-ai-labs/agent-foundation), follow the Docker Compose steps in the README to start the Service stack in an empty <target-directory>. Report the Console URL and confirm that the containers reported healthy by `docker compose` came up without errors.

  • Run a private AI coworker on your own laptop

    Start Open Bot locally with Docker and Bun, then chat with a General Assistant that runs on your machine.

    View prompt
    In the OpenBot repository at <repo-path>, follow the Quick start in README.md to start the stack, then send the message 'Open news.ycombinator.com and tell me the top story' to the /bot route. Report the story title it returns and confirm that the start script printed a passing health check for the API on port 3001.

  • Convert a PDF into an editable Word file on your own machine

    Turn a PDF into a .docx locally with no upload, including scanned pages on macOS and Windows.

    View prompt
    Using the HermesOffice repo at github.com/criptogus/HermesOffice, convert <path to PDF> into an editable .docx file with the local PDF to Word conversion in HermesOffice PDF. Output the .docx path. Verify that the text on page 1 of the .docx matches page 1 of the source PDF.

  • Track which of many coding agents needs your input

    Run several agents at once and see which are working, waiting, or finished in one sidebar.

    View prompt
    Using the diri repo at github.com/cristicretu/diri, check that the sidebar marks each of my running sessions as working, waiting, or finished. Output a list of session names with their status, and confirm that the session in <target-session> is marked waiting when it asks a question.

  • Turn a pile of documents into a cited Markdown wiki

    Drop your files into a browser page and get a wiki of Markdown notes you can ask questions of.

    View prompt
    Using the llm-wiki-v2 repo (package llmwiki2), file the documents in <documents folder> into the wiki, then ask it <question>. Expected output: the answer plus the note paths it cites. Verify that each cited note exists as a Markdown file in ~/llm-wiki.

  • Review working-tree changes and draft a commit message

    Use /diff to read colored changes, then /commit to draft a Conventional Commits message.

    View prompt
    Using the cryer/star-cli repo, run `star` inside <repo-path>, enter `/diff` and then `/commit`, and report the drafted commit message. Verify that the message follows the Conventional Commits format before anyone uses it.

  • Run a personal WhatsApp assistant that remembers you

    A self-hosted agent on your own machine that keeps session context across days of chats.

    View prompt
    In the csr1010/wappy-kit repo, scaffold a project with `npm create @wappy_ai/agent` into ./<project-dir>. Expected output: a generated project folder with a .env.sample listing the model key and WhatsApp fields. Verify that no files were written outside ./<project-dir>.

  • Find a fact on a web page and confirm its source

    An agent opens a page, locates a named link or value, and reports where it points.

    View prompt
    Using the axuse MCP server from the repo at <repo path>, open <target URL>, find the link labeled <link text>, and report its destination. Check that the reported destination matches the link target shown in the accessibility snapshot before answering.

  • Scaffold and validate a new Cursor plugin

    Start a new agent plugin from the create-plugin template and check it is valid before sharing.

    View prompt
    In the cursor/plugins repo, use the create-plugin plugin to scaffold a new plugin named <plugin-name> as a standalone root directory. Output the file tree and the validation result. Verify that .cursor-plugin/plugin.json exists and that the validation reports no errors.

  • See a denied command and a tamper check in 5 seconds

    Run the built-in demo to watch a risky shell call get denied and a rewritten record fail verification.

    View prompt
    In an empty working directory <workdir>, run `uvx --from tracekit-ai tracekit demo --server` and capture its output. Expect an agent run section with Bash 'sudo rm -rf /' marked deny, a line 'Integrity: VERIFIED.', then a tamper test ending in 'Integrity: FAILED.'. Verify that the tamper test failure names a specific seq record.

  • Plan a multi-step change before any code is written

    Make an agent research, ask, and plan a big change before it builds anything.

    View prompt
    Using the Da7-Tech/SureForge skill, research the unknowns in <task description> before asking me questions, then produce a plan that maps each acceptance criterion to a step and a verification method. Expected output: the plan and a plan gate result of READY, REPAIR, or BLOCKED. Verify that no build step appears before the plan gate is READY.

  • Coordinate Claude, Codex and Cursor windows on one project

    Give several AI coding windows shared tasks, acknowledgements and a review step on one codebase.

    View prompt
    Using the Squadra repo at https://github.com/dagoSte/squadra, set up a shared squad for the project at <project path> with Claude Code and Codex windows. Show the install plan first and wait for my approval. Expected output: a list of open tasks and any waits for each window. Verify that `squadra status --all` runs without errors and lists every registered window.

  • Preview benchmark tasks before spending model quota

    Check which tasks, candidate hash, and settings a run would use, with no Docker or model calls.

    View prompt
    Clone https://github.com/Danielxu0208/rsi_eval, install it with `python -m pip install -e .` in a Python 3.12 virtual environment, then run `rsi-eval preview --config <config-path>` for the benchmark config I choose. Report the resolved task references and candidate hash. Verify that the preview ran without Docker or a model call.

  • Turn a handwriting photo into a font with Claude Code

    Photograph your letters, let Claude find and label them, then iterate on the font by chatting.

    View prompt
    Use the draw-your-font skill from the danilo-znamerovszkij/draw-your-font repo on the photo at <photo-path>. Build a font from the handwritten letters and save the TTF, WOFF, and WOFF2 files to <output-dir>. Verify that the preview renders the letters A, a, and g correctly before reporting the output files.

  • Run a first PPO experiment on one GPU

    Install miniVERL, sample prompts and train a Qwen3-0.6B PPO run with a length reward.

    View prompt
    Work in the miniverl repo (DaoyuanLi2816/mini-verl) on this machine. Install it, sample 8 prompts into data/rl-prompts.parquet, run the hydra-ppo example with run ID <run-id>, and report the path to rewards.jsonl. Verify that the dry run passes before the full run starts.

  • Turn a folder of scanned PDFs into markdown files

    Batch-convert scanned PDFs to one markdown file each, using all CPU cores.

    View prompt
    In the repo datalab-to/indra, install indra-ocr with pip and run `indra-ocr <folder>/*.pdf --out results/`. Expected output: one .md file per input PDF in results/. Verify that each .md file is non-empty and that the CLI exit code is 0, or list the files that failed.

  • Pretrain an EBFM model to a chosen token budget

    Prepare DCLM data and run a full pretraining job with a set token count.

    View prompt
    Using the OpenEBFM repo (datamllab/OpenEBFM), prepare the dclm dataset and run pretraining with TARGET_TOTAL_TOKENS set to <token_budget> via runs/train.sh. Report the path of the final checkpoints_hf/ export and confirm it contains config.json and model.safetensors.

  • Learn LLM inference concepts without a GPU

    Read Part I to understand KV Cache, prefill vs. decode, and the benchmark metrics before touching code.

    View prompt
    Clone https://github.com/datawhalechina/zero-to-sglang and read the Part I chapters in course-material/eng/part1/. Write a one-page summary of how KV Cache reduces repeated attention work and list the four benchmark metrics with a one-line definition each. Verify that every definition matches the chapter text.

  • Run coding agents on your own Linux server

    Install the core on a VPS or home server so Claude Code and Codex run there, not on your laptop.

    View prompt
    Using the cloudroom-core repo, install the core on <server-host> following docs/setup.md, then create one session for Claude Code using the HTTP API in docs/api.md. Expected output: the session ID and the agent's first reply. Verify that the API rejects a request sent without the secret token.

  • Move a running agent task to the cloud before you leave

    Hand a half-finished coding task from your Mac to a cloud agent without losing the chat.

    View prompt
    Using the Cloudroom app in the cloudroom-gui repo, move the running thread for <project or task name> from the Mac to the cloud with Teleport. Expected output: the same thread running in the cloud with the same chat, model, and effort. Verify that the chat history and model match before you report success.

  • Build a KPI dashboard from warehouse SQL with an agent

    Have a coding agent turn your SQL queries into a validated, live-previewed YAML dashboard.

    View prompt
    Using the dbt-charts repo, install the CLI, run `dct skills intro`, and write a KPI board for the metrics described in <placeholder> as YAML under charts/. Run `dct validate` on the file and report any errors. Verify that the board renders in `dct serve`.

  • Test whether an agent can reach a payments API directly

    Compare direct, shadow and enforced requests before any real traffic goes through a gateway.

    View prompt
    Using the decionis/agent-safe-pipeline repository, install AgentSafe and run `agentsafe test`. Report the Exposure line and the Verdict for the boundary test against <your-api-url> if you have one, otherwise against the built-in synthetic target. Confirm the exit code is 0 before you say the boundary holds.

  • Practise customer delivery cases on your own machine

    Run FDE Gym locally and work the three open cases with a coding agent.

    View prompt
    In the fde-gym repository at <path>, follow the README quick start to download the three open cases into cases/ and start the site with docker compose. Report the URL the site answers on and the names of the case folders present. Verify that cases/ contains the three downloaded cases before reporting success.

  • Apply the Solid Glass look to a shadcn/ui project

    Install one stylesheet so existing shadcn/ui components take on the Solid Glass material.

    View prompt
    In the shadcn/ui project at <project-path>, add the Solid Glass stylesheet from the deeplethe/solid-glass repository using `npx shadcn@latest add deeplethe/solid-glass/solid-glass`, import it after the Tailwind and shadcn stylesheets, and remove the duplicate `:root` and `.dark` colour variables. Report the files changed and confirm the build still runs.

  • Find which contract terms applied on a given date

    Load a master agreement and its amendments, then ask which terms were in force on a date, with the source sentence.

    View prompt
    Using the Utopia repo at <repo path>, help me load the agreement files at <folder> into a knowledge base and ask which payment terms applied on <date>. Expected output: the terms in force on that date, the amendment they came from, and the cited sentence. Verify that each cited sentence appears in the source document before reporting the answer.

  • Start the DeepSeek Harness Web UI with one command

    Launch the dsh Web UI on your own machine with a single npx command.

    View prompt
    In the deepseek-harness project, run `npx @deepseek-ai/dsh web --no-open` on <target machine> and report the local URL the server prints. Verify that http://127.0.0.1:3080 returns the Web UI page before reporting success.

  • Generate a runnable TypeScript workflow from plain English

    Describe a multi-step job in one sentence and get a runnable TypeScript workflow module.

    View prompt
    Using the deer-workflow repository (deerwork-ai/deer-workflow), generate a runnable TypeScript Workflow for <target job description> with the deer-workflow create command, save it to workflow.ts, and run it with a sample input. Expected output: a workflow.ts file plus a run result. Verify that the run finishes and that the phases in the file match the steps described in the job.

  • Verify an agent work package offline without the vendor

    Check a signed Surface or Acceptance bundle with the owp CLI, no access to the original platform.

    View prompt
    Using the OpenWorkProof repo at https://github.com/dengyier/OpenWorkProof, install the openworkproof package with pip and run `owp acceptance-bundle-verify <DIRECTORY>` on the bundle at <DIRECTORY>. Report the result and the exit code, where ACCEPTED is 0 and REJECTED is 2. Verify that the command ran without reading any private key from the bundle folder.

  • Replace part of a photo with an AI layer that matches

    Select an area, describe the change, and get a colour-matched layer you can mask, blend or undo.

    View prompt
    Using the Scumble repo at https://github.com/DenRakEiw/scumble, help me replace the selected area of <path to picture> with <description of change> through my API key for <provider>. Expected output: an edited picture with the result as a separate layer. Verify that the result appears as its own layer and that the status line names the provider used.

  • Review uncommitted Git changes before committing

    Get a staged review of your current diff and read the findings in a local dashboard.

    View prompt
    In the jev-review repo, run `npm run review:changes:save -- <path to git repository>` and then `npm run dashboard`. Report the saved review's findings grouped by category. Verify one finding by reading the cited diff hunk and state whether it looks like a real issue or a false positive.

  • Keep a Claude Code session going past a usage limit

    Pool two or more accounts so a long coding session switches accounts instead of stopping.

    View prompt
    Using the DevDock-AI/claude-unlimited repo, install the daemon and add a second account, then start a Claude Code session with `claude-unlimited code` in <project-path>. Expected output: the dashboard at http://127.0.0.1:4317/ lists at least two accounts. Verify that the dashboard shows both accounts and that the session starts without an error.

  • Run Claude Code in a browser workspace on your server

    Install Agentbox on a Linux server and code with Claude Code from any browser.

    View prompt
    Use the agentbox repo at github.com/devilcoolyue/agentbox to set up a Claude Code workspace on the server <server-host>. Confirm that agentbox.service is running and that the web console answers on port 8180, then report the workspace URL. Do not share the generated admin password in logs.

  • Keep each of your own accounts in its own browser profile

    Run several isolated local browser profiles, each with its own cookies, cache, and proxy.

    View prompt
    Using the repo DFarm6/Prism-Browser-Community, list the profile settings a new profile needs for <account name>, including proxy fields if <proxy host> is given. Expected output: a short checklist of profile fields. Verify that each profile is listed with its own user-data directory after saving.

  • Suggest the right agent skill for each Claude Code step

    Connect a Claude Code session to SkillRanker so each next step gets a ranked, advisory skill suggestion.

    View prompt
    Using the Dicklesworthstone/skillranker repo, preview the Claude Code hook change with `sr install-hook claude` for the project at <project path>, then apply it only after I confirm. Expected output: the proposed settings diff, then a confirmation that the hook was applied. Verify that `sr doctor --json` reports the hook as configured and that my TYPESAFE_API_KEY is set without printing its value.

  • Keep coding when one provider's quota runs out

    Route Claude Code, Codex or Cursor through one gateway that falls back to the next healthy model.

    View prompt
    Using the diegosouzapw/OmniRoute repo, configure <agent> to send chat requests to http://localhost:20128/v1 with model auto/thrifty. Run one test request with curl and report the completion text it returns. Verify that the request succeeds with the OmniRoute key and no provider error is returned.

  • Switch Codex and Claude Code to a new API provider

    Add a provider once with its API address and key, then switch between providers with one click.

    View prompt
    Using the uni-switch project at github.com/dieqiyun/uni-switch, add a provider with API address <api-address> and the API key stored in <key-env-var>, then confirm the provider appears in use for the chosen client. Expected output: the provider listed as in use, with a note to restart the client and start a new conversation. Verify that the local config backup was created before the change.

  • Watch tokens per second and TTFT on a local server

    Attach the dashboard to a running llama-server and see tok/s, time to first token and GPU load update live.

    View prompt
    Using the repo DingoOz/llm-visuals, run `cargo run --release` against a llama-server listening on <server-port> with metrics enabled. Expected output: a dashboard listing that server with live tokens per second and time to first token while a request runs. Verify the model name and port shown match the server you started.

  • Run a durable agent on your own machine

    Start a device server and web hub so an agent keeps running after you close the browser.

    View prompt
    In the Durable Pi repo at <repo path>, follow the Manual Install steps in the README up to starting the hub on http://localhost:4781. Report the URL that responds and the names of the device and session shown in the web UI. Verify that the device appears as local in the network tree.

  • Find the one AI coding session that needs you

    See every Claude Code and Codex session in one picker and jump to the one waiting on you.

    View prompt
    Install Session Kit from https://github.com/dob323/session-kit using the latest release artifact, then run `session-kit doctor`. Confirm that `kit` opens a picker listing the Claude Code and Codex sessions on <host>, and report the state shown for each session.

  • Fill repetitive web forms with DomA in your browser

    Let DomA fill and submit repeated web forms in Chrome or Edge using your own LLM key.

    View prompt
    Use the open-source repo dom-actions/doma as a browser agent to fill the web form at <target form URL> with the values in <data file>. Expected output: a report listing each field filled and any field left empty. Verify that the form shows the intended values before submission.

  • Review and approve agent edits before keeping them

    Install a diff approval plugin so every agent edit can be reviewed, kept or reverted per file or block.

    View prompt
    Using the DSH repo at https://github.com/Dominic789854/awesome-deepseek-harness as the index, install the dsh-diff-approval plugin from github.com/9087/dsh-diff-approval into the web profile. Ask DSH to edit <target-file>, then report whether the full diff appears and whether a single block can be reverted without touching the rest. Verify by checking the file content after the revert.

  • Collect a whole infinite-scroll feed in one call

    An agent scrolls, dedupes and returns a full feed as one artifact.

    View prompt
    Use the bladebro MCP server to open <feed URL> and run act collect until the feed stops loading new items. Return the collected items as one artifact. Verify that no item appears twice in the output.

  • Give a coding agent live web search and fetch

    Register DonSeTch as an MCP server so Claude Code or Cursor can search and read current web pages.

    View prompt
    Using the donsetch MCP server, search the web for <topic> and fetch the top 3 sources. Return a bulleted summary where each point has its source URL, and confirm each fetch returned page text.

  • Answer business phone calls with an AI agent on your PBX

    Route inbound calls from an existing PBX extension to an AI agent that can transfer, take messages and log calls.

    View prompt
    In the Dpro-at/Tel-Agent repo, follow the README quick start and the phone channel requirements to connect a PBX extension for <PBX type and extension>. Expected output: a test call from <test number> that routes to the AI agent and appears with a transcript in the conversation archive. Verify that ENCRYPTION_KEY is set in .env and that the dashboard loads at http://localhost:38471 before placing the call.

  • Fix a failing test or bug in a repo from the terminal

    Give AlphaCode a bug report and let it inspect the code, edit files, and run tests.

    View prompt
    Use the dragonked2/alphacode repo to fix the failing test in <project path>. Run the relevant tests after the change and report the changed files and test results. Verify that the failing test now passes and that no other tests were newly broken.

  • Give your AI assistant the day's work without pasting it

    Register the app as an MCP server so your assistant can read the day's record and notes directly.

    View prompt
    Using the ambient-context MCP server from the dedupedai repo of dragthelake/ambient-context, read the day <placeholder> with the reading-days tools and summarise the work in five bullet points. Expected output: five bullets, each tied to a block in the record. Verify that every bullet names an app or file path that appears in the Days folder for that date.

  • Reproduce STEP Quant@6 results on Qwen3.8-27B

    Calibrate a 6-bit STEP Quant plan, serve it with SGLang, and run the long-generation evaluation suite.

    View prompt
    In the STEPQuant repo at <repo_path>, follow the Quick Start in README.md to calibrate the stepquant6 plan for the Qwen checkpoint at <model_path>, then run the evaluation suite with the fp32 and stepquant6 formats. Report the average accuracy for each format and confirm the STEPQuant@6 score is close to the FP32 score in the README results table.

  • Replay a finished story without any API keys

    Start Asamana locally and browse the two bundled example worlds with no keys.

    View prompt
    Clone the repo at https://github.com/dreamscroll-lab/asamana, then run ./deploy/asamana.sh start without configuring keys. Report the name of one example world you can browse and the number of characters it lists. Verify that the backend starts without an error about missing API keys.

  • Design a reliable service with failure and capacity notes

    Follow the reliable service route from scale and consistency through caches, queues, and backpressure.

    View prompt
    Using the enterprise-system-design repository, read reference/01-system-design-foundations/06-scale-from-one-to-one-million.md, then write a design artifact for <target service> listing requirements, failure modes, and capacity reasoning. Verify that every failure mode names a detection signal.

  • Edit a large codebase in a fast native editor

    Open a big project in a native, Rust-built editor that stays responsive on large views.

    View prompt
    Using the dstrml/wu repo, install Wu on this machine and open <project-path> in it. Expected output: the project tree visible in the Wu editor. Verify that a large file in the project opens without visible delay.

  • Run several coding agents on one backlog in parallel

    Split a backlog into task cards and let agents work on them at once without write conflicts.

    View prompt
    In the dualface/kander repo, load the Kander rules and create one task card for the requirement <requirement description> with clear acceptance criteria, then confirm it was launched through the kanban flow. Report the card ID and its status. Verify that the card appears on the board with its own isolated workspace.

  • Find the original entry point of a packed binary

    Use an AI assistant to load a packed executable in x64dbg, detect its OEP, and dump the module to disk.

    View prompt
    Using the x64dbg-MCP-Server MCP tools at http://localhost:9094/ with my Bearer token, load <target executable path>, call DetectOEP, then call DumpModule. Report the Original Entry Point address and the dump file path. Verify that the dump file exists on disk.

  • Find the code behind a behavior before an agent edits it

    Ask a repository question and get files, leads, and source excerpts to start an unfamiliar change.

    View prompt
    Use the jevgrep skill in this repository to run `jg` with the question "<question about the behavior>" against <target path>. Report the files, line references, and source excerpts it returns, and confirm each cited file exists before you propose any edit.

  • Generate a 3D CAD model from a text description

    Describe a part to your agent and get it back as a STEP, GLB, STL or 3MF file.

    View prompt
    Using the text-to-cad plugin from https://github.com/earthtojake/text-to-cad, build a 3D model of <part description> and export it as <STEP, GLB, STL or 3MF>. Return the output file path and confirm the file opens in the CAD Viewer.

  • Make a new video in the style of one you love

    Drop in a reference video and a one-line brief to get an original video with the same pacing and look.

    View prompt
    In the reelmimic repo, start the local web app, submit <reference video path or link> with the brief <one-line brief>, and approve the plan once it appears. Expected output: a finished video in the project folder with a final review result. Verify that the Production line tab shows every shot passed review before you report success.

  • Run several coding agents side by side in one app

    Keep projects and separate agent sessions from different CLIs in one native desktop window.

    View prompt
    In the waku repo at <path to Waku checkout or install>, confirm that Waku can see at least one agent CLI by opening the app and listing the detected agents for the project at <project path>. Expected output: a list of detected agents and the sessions created for each. Verify that each session shows its own transcript.

  • Make a game-ready Unreal crate with baked normals and LODs

    Have an agent optimize a crate model, bake its normal map, create LODs and export it for Unreal.

    View prompt
    Using the blender-skills repo, make <target crate model> game-ready for Unreal with baked normal maps and LODs, then export it. Expect the exported file, a list of LOD levels and the baked texture files. Verify that the export contains every LOD and that the normal map maps to the correct UV set.

  • Send every app's LLM calls through one endpoint

    Run one gateway that forwards OpenAI-style requests to your provider keys.

    View prompt
    Using the eliasbiondo/antirion README, configure the OpenAI SDK in <project path> to use base URL http://localhost:8080/v1 and the gateway key in ANTIRION_API_KEY, then send a chat request with model chat. Expected output: a chat completion JSON response. Verify that the request appears in the Request log in the console.

  • Find a ready-made bot prompt and paste it into your agent

    Search the directory by keyword, category, or integration and copy a prompt that sets up a scheduled bot.

    View prompt
    Use the botdirectory.ai API at https://api.botdirectory.ai/api/bots?q=<keyword>&limit=10 to find listings that match <keyword>. Return the name, integrations, and detail URL of the top 3 results as a short list, and confirm each result has a non-empty prompt or description before you suggest it.

  • Run a persistent AI bot on your own computer

    Install Rakazo with published Docker images and chat with a bot that keeps its own memory.

    View prompt
    In the Rakazo repo at https://github.com/elie222/rakazo, follow the Quick start (published images) section to install Rakazo into a folder named <target-folder> on this machine. Report the local URL and confirm that http://127.0.0.1:5173 loads a sign-in page. Verify that the .env file was created in <target-folder> with random secrets.

  • Run a robot task from a browser console

    Start the Web console, create a conversation, and give the robot a task with live camera views.

    View prompt
    In the EMERGE-Policy repo, follow the README Quick Start to start the Web console with `emerge web`, create a conversation, and submit the task "<task>". Report the scene that was created and the task progress shown in the console. Verify that the conversation has its own isolated scene and workspace before reporting success.

  • Chat with AI models on a 2007 Nokia phone

    Deploy the Go server, build the Java ME app and pair an old Nokia to chat with Claude or other models.

    View prompt
    In the AIKON repo, walk me through the setup in docs/SETUP.md for a server at <server-host> and a Nokia <model> phone. List each command in order with the exact placeholder I must fill, and state which step needs a manual action on the phone. Verify by confirming that the test-mode deploy finishes before any key is set.

  • Hand off a coding task between harnesses in one window

    Keep one Codex Desktop window and pass a task from one harness to another for a second pass.

    View prompt
    Using the repo emo-xiaoyu/harness-mix, set up Harness Mix on this machine and hand the current task at <task description> from the current harness to <target harness> with the independent review mode. Report the checkpoint created and confirm the target harness resumed its native session.

  • Find a literal NASA clip for a script line

    Search NASA footage for a line of script, preview it and keep only approved clips with sources.

    View prompt
    Using the get-brolls repo, search NASA for footage matching the line "<script line>" in project folder <project folder>, preview the top candidate, and wait for my approval before running fetch. Expected output: a verified clip in brolls/clips/ and an entry in brolls/credits.md. Verify that verify reports the count of approved clips.

  • Run a local Git server and push a repo to it

    Start a single Enroute node on your machine and push a repository to it in minutes.

    View prompt
    Using the enroute-sh/enroute README, install enroute, start `enroute dev`, and push the <project-dir> main branch to http://127.0.0.1:8080/<repo-name>.git. Report the output of `enroute repo list`. Verify that <repo-name> appears in that list.

  • Check what an agent read before it edited a file

    Replay a session to see which files the agent opened before changing code, and which it never opened.

    View prompt
    In the agentplay repo at https://github.com/Entelligence-AI/agentplay, run `uvx agentplay` and open the session that edited <target file path>. Report which files the agent read before the first edit to that file and which related files it never opened. Verify by confirming each listed read appears earlier than the first edit on the timeline.

  • Run several app branches side by side without port clashes

    Give each branch its own slim device, worktree, and leased Metro port from one dashboard.

    View prompt
    Using the simfleet repo (entropyconquers/simfleet), run `simfleet lane start "$PWD" development debug` inside <path-to-app> and then `simfleet lane launch`. Expected output: a lane with a leased Metro port and the dev client opened on that port. Verify with `simfleet ports` that the leased port appears in the list.

  • Measure shelf attention from a fixed store camera video

    Run the gaze pipeline on a fixed-camera clip to rank which shelf zones draw attention.

    View prompt
    Using the repo escudero/brandpose, run scripts/gaze_sim_v2.py on the fixed-camera video at <video path> with --max-seconds 60, using the flags in the README. Report the number of estimated gazes, shoppers and zones with attention, and the output folder. Verify that outputs/v2 contains results and that the attention figures are labeled as model estimates, not ground truth.

  • Plan a project and agree on which model does each part

    Get a plan, a model recommendation for each part, and your approval before any building starts.

    View prompt
    Using the codex-on-crack package in <project folder>, run the crack-plan skill to list my available models and propose a plan that assigns each phase to a model. Expected output: a written plan with one model recommendation per phase and no code changes. Verify that the plan waits for my approval before any build step begins.

  • Build a reading list for LLM game NPC agents

    Collect the Play and Act papers on LLM and RL agents that control game characters.

    View prompt
    Using the Eurekaleo/awesome-ai-for-games README, list the Play and Act papers that involve game NPCs or persona-driven characters, with their paper and code links. Verify that each entry you return appears under the Play and Act heading.

  • Fetch task-specific skills from SkillHub for an agent

    Search the hosted SkillHub catalog with a plain task description and inject the matching SKILL.md text into a prompt.

    View prompt
    Using the SkillCorpus API at https://skillhub.evermind.ai/openapi/v1/skills, search for skills matching the task <task description>, pick the most relevant result, fetch its skill_md, and output the injected prompt text. Verify that the returned skill_md is non-empty and that the skill license is shown in the metadata before using it.

  • Score one agent patch on a SWE-sweep task

    Run a unified diff against one benchmark task and get graded Harbor results.

    View prompt
    Using the repo at facebookresearch/swe-sweep, run the Harbor command for the task tasks/<task-name> with the patch at <path-to-model.patch> as the patch_path, writing output to jobs/. Report the directory where results were written and whether the trial completed without errors.

  • Read a Claude Code or Codex session step by step

    Load one authorized agent session file and browse its events in a local timeline.

    View prompt
    Using the TraceCrate repo at <repo path>, run npm ci and npm run dev, then load the authorized session file <session file path> through Choose files. Expected output: a Timeline listing that session's events with search and kind filters working. Verify that token totals appear only where the file reports them and that missing values are shown as unknown, not zero.

  • Run Kimi K3 text completions on an 8 GB laptop

    Generate a short continuation with the full 2.78T model on one CPU, streaming weights from disk.

    View prompt
    In the repo FareedKhan-dev/kimi-k3-in-c, run the laptop preset with --trunk <trunk_dir> and checkpoint directory <checkpoint_dir>, using the prompt "The capital of France is" and --gen 8 --incremental. Expect generated text and a PEAK RSS line. Verify that the reported peak RSS stays near 8.24 GB.

  • Run Codex in Herdr from your phone

    Start a coding task on a remote machine from a phone and check its output in the Herdr terminal.

    View prompt
    Using the farlume/termish README, give step-by-step instructions to connect a phone to <host> over SSH, open Herdr, and start Codex with the task <task>. Expected output: a numbered checklist of app steps. Verify that the checklist includes host key verification before the first login.

  • Design a logo, type and palette for a new brand

    Build three identity sets from one brief, pick one, and get a brand guidelines kit.

    View prompt
    Using the repo fatihaydost/brand-identity-skill, design a brand identity for <business brief> with three sets, then stop at the board for my pick. Expected output: identity cards for each set and, after my choice, a brand guidelines kit. Verify that every set shows its contrast and licence measurements before the board.

  • Make a launch video from one sentence

    Describe a video in one line and get a rendered final.mp4 on your own machine.

    View prompt
    Using the showtime skill from the FavioVazquez/showtime repository, make a 20-second launch video with a voice-over for <project name>. Expect a new folder under showtime-out/ containing final.mp4, poster.jpg and share.txt. Verify that showtime qa reports no FAIL before you report the result.

  • Show a live agent status in a React app

    Render a robot head that changes face and motion as the agent moves between states.

    View prompt
    In the React project at <project path>, run `npm install robot-heads` and render a RobotHead whose state follows the agent's status, mapping each status to one of the nine README states. Expected output: a component file that type-checks against React 18 or newer. Verify the prop names against the installed package types before finishing, because the README props block is not fully legible.

  • Learn AI basics through 51 labs in a browser

    Work through hands-on AI labs in the browser with no install and check understanding at each lab's end.

    View prompt
    Using the Fazmin/AILearningGuide repo, open https://fazmin.github.io/AILearningGuide/ in a browser, choose Simple reading mode, and complete lab 1 by following its "Try this" hint and checkpoint. Expected output: lab 1 marked complete. Verify the home screen progress now shows lab 1 as done.

  • Compare flight fares across a date range from your assistant

    Have your assistant check each date in a range on a booking site and report the cheapest fare per day.

    View prompt
    Using the invisible_playwright_mcp server from feder-cr/invisible_playwright_mcp, open <booking-site-url> and check the cheapest economy fare for one adult, one checked bag, from <origin> to <destination>, for each date from <start-date> to <end-date>, clicking the days in the calendar widget one at a time. Expected output: one line per date with the cheapest fare or the words no availability. Verify that no booking was submitted.

  • Make a 15-second product launch film with one camera

    Have a coding agent turn a short app description into a launch film where every beat carries into the next.

    View prompt
    Using the onetake skill in the feitangyuan/onetake repo, make a 15 second launch film for <app name and one-line description>. Output a 1080p30 draft video file and its beat sheet. Verify that the continuity check passes and that every boundary in the beat sheet names what carries across it before you report done.

  • Let a coding agent search your product docs

    Deploy Carrel locally and give Claude Code or Codex a search skill over your own document folders.

    View prompt
    Using the Carrel repo at https://github.com/FengZhenfei/carrel, set up the carrel-search skill for this agent and query the search endpoint at http://127.0.0.1:9810/search with a question about <topic>. Return the answer with the source passages cited. Verify that the response contains source passages before answering.

  • Screen companies as they stood on a past date

    Run a metric threshold screen on SEC filings using only what was public on a chosen date.

    View prompt
    In the Qanat project at <project-folder>, run a screen for metric pe below 30 as of <date> using the qanat screen command. Return the companies that passed, the count evaluated, and the count that could not be evaluated. Verify that the list is shown together with the unevaluated count so no companies are silently dropped.

  • Turn a rough idea into an agent-ready Linear issue

    Interview with /finn-spec until the behavior is clear, then get a Linear issue with acceptance criteria and non-goals.

    View prompt
    In the GitHub repo at <repo path>, run the /finn-spec skill for this idea: <idea text>. Expected output: one Linear issue with AC-N acceptance criteria and NG-N non-goals. Verify that every acceptance criterion describes an observable outcome before reporting the issue link.

  • Plan a feature with an AI before any code is written

    Explore, propose, apply, and archive one change so the agent builds only what you agreed to.

    View prompt
    Using the OpenSpec repo at Fission-AI/OpenSpec, set up OpenSpec in <project-path> by running the install and `openspec init` steps, then use /opsx:explore and /opsx:propose <change-name> to create a change folder. Expected output: openspec/changes/<change-name>/ containing proposal.md, specs/, design.md, and tasks.md. Verify that the tasks file exists and summarize it for human review before running /opsx:apply.

  • Keep a long Pi coding task going across fresh windows

    Run a long Pi task that rolls into fresh context windows using saved notes instead of summaries.

    View prompt
    Using the pi-posthorse repo (fitchmultz/pi-posthorse), set up Posthorse for the project at <project-path>, then give Pi a multi-step coding task and ask it to save task state in notes before rolling over. Expected output: a task note saved under .pi/notes/ in the project and a fresh context window started. Verify by running `pi list` and confirming pi-posthorse appears as an installed source.

  • Open an existing .rrd recording in the Dalaran viewer

    Replay an upstream .rrd recording on one timeline without converting it first.

    View prompt
    Using the Flaminis/Dalaran repository, install dalaran-sdk with pip and open <recording_path> with the dalaran command. Report whether the viewer opens the file and list the entity paths you can see. Verify that the timeline shows data from more than one sensor.

  • Add a polished message action bar to an AI chat

    Drop a finished copy, regenerate, feedback and read-aloud bar under each AI reply in one file.

    View prompt
    In the affectui repo context, install the message-actions item into the <project-path> Next.js or React 19 project using `npx shadcn@latest add https://www.affectui.com/r/message-actions.json`, then render it under the last assistant message in <chat-component-file>. Expected output: a MessageActions import and usage in that file with your existing handlers wired to props. Verify the project still builds and the bar renders with no console errors.

  • Trace a commit back to the agent session that wrote it

    Find the session behind a commit and read the command and result evidence it produced.

    View prompt
    In the flopwire/flopwire repo context, run the trace command for the full commit ID <commit-sha> and report the session ID and the command and result evidence it returns. Verify that the session ID appears in `flopwire sessions --repo . --since 30d`.

  • Resume an interrupted Claude or Codex coding task

    Find a stopped session in the local workbench, review its evidence, and prepare a continuation command.

    View prompt
    Using the Frankie-Xu/threadport repo built with Node 24, start the local workbench with `node dist/src/cli.js ui --no-open` and attach the session in <project-directory> as a task. Report the observed files, commands, and failures, and confirm that the continuation text contains no unconfirmed objective before any launch.

  • Run the synthetic fly-brain demo without hardware

    Clone the repo and watch the mock neural backend turn synthetic frames into motor commands.

    View prompt
    Clone https://github.com/Himas1211/flybrain-robot-bridge, create a Python 3.11 virtual environment, install it with pip install -e ".[dev]", and run python -m flybrain_robot.main --backend mock --synthetic. Report the final motor commands and watchdog state. Verify that the run finishes without opening a network connection or camera.

  • Point a human at the Allow button an agent cannot press

    An agent draws an arrow and sign at the permission button so the human clicks it.

    View prompt
    Use the bigarrow CLI from the repo franzenzenhofer/big-arrow-on-the-screen to point at the button labelled <button label> in the app <app name> with the sign text "<sign text>". Expected output: a JSON result from `bigarrow point ... --json` with an exit code of 0. Verify the exit code is 0, and if it is 4 run `bigarrow doctor` and report which app needs Accessibility.

  • Compare 12 coding-agent harness results side by side

    Open the live FrontierHarness results to see pass rate, cost, and speed for each harness.

    View prompt
    Open the repo frontier-harness-eval/eval and read the Full results table in its README. Report the harness with the highest pass rate and the harness with the lowest median cost per pass, with their values. Verify that both values match the table row for each harness.

  • Shortlist decision models from the JevBench board

    Compare open-weights and hosted decision models on accuracy, calibration, speed and cost before you pick one.

    View prompt
    Using the JevBench project at github.com/fstandhartinger/jevbench, read the release manifest at https://benchmarkheaven.com/api/jevbench/manifest and the results JSON at https://benchmarkheaven.com/api/decision-results/jevbench/v1.6.1/json. Return a table of the five best open-weights systems for <target workload> with their Intelligence, Calibration, Speed and Cost values, marking any null value as missing. Verify that the release source_sha256 matches 5cd8c1332226ea9c179883d2285c0d8b8cc593ae38f2645197364a7ddd9c83c1 before you report results.

  • Follow a running agent session as a live graph

    Watch the main agent, its subagents and their tool calls update live in your terminal.

    View prompt
    In the zoetrope repo (furkankly/zoetrope), install the zoe binary and run `zoe` from the project directory at <project-path> to follow its newest live session. Expected output: a live flow graph showing the main session and any subagents with their current tool. Verify that at least one agent card shows a status and tool count before reporting success.

  • Import the Top 200 feeds into a reader in one step

    Download the recommended 200-feed OPML and import it to start reading across 14 categories.

    View prompt
    Use the tidings-rss repo to import tidings-top200.opml into <reader-name>. Report how many feeds were imported and list any feed that returns no articles on first load.

  • Fix failing tests in a repo from the terminal

    Point FuXi at a repository with failing tests and have it read, edit, and rerun until they pass.

    View prompt
    In the repository at <repo-path>, run FuXi from the terminal with the prompt 'Fix the failing tests in this repository.' Expected output: a summary of the files FuXi changed and the result of its test run. Verify by running the project's own test command yourself and confirming the previously failing tests now pass.

  • Check delayed IHSG quotes and valuation from a terminal

    Install Idx and pull delayed prices, P/E and dividend yield for several IDX tickers in one command.

    View prompt
    Use the idx command from the fzn0x/idx repo to fetch quotes for <tickers such as BBCA,BBRI,TLKM> by running `idx -o json stocks quote <tickers>`. Return price, change percent, P/E and dividend yield for each ticker as a short list. Verify that the response includes a last trade timestamp and state that the data is delayed.

  • Edit a photo by describing the change in plain words

    Install Kokon, let it set up models, then type an edit like 'make it golden hour' and get the result locally.

    View prompt
    Use the Kokon app on this machine to edit the photo at <photo path> with the instruction '<edit description>'. Save the result next to the original and report the output file path. Check that the output has the same width, height and aspect ratio as the input photo.

  • Transform selected text in any macOS app

    Select text anywhere on macOS and pick a case change, search, math, or custom action from the popup.

    View prompt
    Using the OpenClip repo at https://github.com/ganeshmshetty/openclip, install the app with `brew install --cask openclip` and confirm Accessibility permission is granted. Select <target text> in a text editor and report which actions the contextual bar shows. Verify that a case transform action is listed.

  • Make a sourced, interactive biology figure from one prompt

    Turn a biology mechanism into a cited, toggleable standalone HTML figure in Claude Code.

    View prompt
    In the Garinmckayl/anima repo, use the /anima Claude Code skill to build a standalone HTML figure of <biology subject and mechanism>, with a toggle that changes the mechanism and a sources block. Expected output: one standalone HTML page in dark and light themes. Verify that every displayed number has a cited source with species, conditions and units, and that the page carries the educational-not-medical-advice note.

  • Render a title card to MP4 from TypeScript

    Write one TypeScript file that builds a 1080p60 title card and renders it to a hardware-encoded MP4.

    View prompt
    Using the framefields repo, write a TypeScript script that builds a 1920x1080, 60 fps composition with a title card reading <title text>, renders it with renderVideo to output/<file name>.mp4, and runs it. Expected output: an MP4 at that path. Verify the file exists and that the printed Rendered to path matches it.

  • Set up a family TV with a clean, ad-free home screen

    Turn a sponsored-ad Android or Google TV into a clean home screen over Wi-Fi, with no root and nothing uninstalled.

    View prompt
    Using the Gathin23/cleanyourtv repo as context, follow PROMPT.md for the TV model <tv-model> on the local Wi-Fi network. Back up the installed package list and settings, disable the manufacturer ad and telemetry packages with pm disable-user, and install the launcher as the default home screen. Expected output: a backup of the package list, a list of disabled packages, and confirmation that the launcher is the default home. Verify that no packages were uninstalled.

  • Generate images from a text prompt in Codex

    Install the skill once, then create a finished GPT image from one natural-language request.

    View prompt
    Install GPT Image Skill from https://github.com/GENEXIS-AI/gpt-image-skill using the AGENT_INSTALL.md contract, then generate one image of <subject> at <aspect ratio> with high quality. Expect a PNG under /generated-images and a PATH=... line in the output. Verify the file exists and that the output did not use OPENAI_API_KEY or the Images API.

  • Have AI revise a Word file and review every change

    Open a .docx in GenOffice Docs, ask the AI for an edit, and accept or roll back the tracked changes.

    View prompt
    Using the GenOffice app on this machine, open <path to .docx> in the Docs editor, ask the AI to tighten the Overview section, and keep edits as tracked changes. Expected output: the saved .docx with revisions visible. Verify that the file opens in Word with the original styles and comments intact.

  • Connect an agent to the growth.engineer catalog

    Add the read-only MCP server so an agent can search workflows, tools and companies.

    View prompt
    Use the growth-engineer MCP server at https://www.growth.engineer/mcp to search for workflows about <goal>. Return the title and key of each match and open the first one with get. Check that the returned file has a title, inputs and steps before you report back.

  • Point opencode at a pool of coding subscriptions

    Run one local endpoint that spreads opencode requests across several Codex or Copilot accounts.

    View prompt
    In the underclass repo at <repo path>, start the server with the proxy key and UI token set as environment variables, run `cargo run -- connect`, then run one opencode prompt against the underclass provider. Expected output: a completed response and a usage row in the admin page for <account label>. Verify that the admin page lists the account as healthy after the request.

  • Flag docs that no longer match the code

    Create a reviewer bot that finds one documentation mismatch in a repo and proposes a fix.

    View prompt
    Using the gitbot-hq/GitBot package, install it with npm install -g @gitbot-hq/gitbot, start it from your projects folder, and create a bot whose instructions find one documentation mismatch in <repo folder>. Expected output: one mismatch with an explanation and a proposed small fix, with no file edits until the user approves. Verify that the bot asked before editing any file.

  • Pick evaluation tools for a customer LLM app

    Shortlist evaluation and observability tools for a customer's LLM or RAG app.

    View prompt
    Using the Tools section of the global-fde/awesome-fde-resources README, shortlist three evaluation tools for a <customer LLM app>. For each tool, state the feature match from its own repo README and the main gap. Verify each link opens to the named project before you report.

  • Carry project conventions into every new coding session

    Reuse build rules, test layout and service flags from past sessions instead of re-explaining them.

    View prompt
    Using the Gnosil/semantix repo, install it, extract slices from <session.jsonl> into .semantix/project.db, then run semantix inject with a query describing <task>. Report the slices returned with their retrieval zone and source session. Verify that each returned slice names a session that exists in <session.jsonl>.

  • Audit a released SoT controller checkpoint

    Confirm a released controller file is intact before you rely on it in a study.

    View prompt
    Using the repo GongZhiren/State-of-Thought, create a virtual environment, install it with python -m pip install -e ., then run sot checkpoint verify on <checkpoint path>. Report whether verification passes and the SHA-256 identity printed, and verify the result against the checkpoint hashes described in REPRODUCIBILITY.md.

  • Run a phone test from your AI IDE chat

    Describe a test in your AI IDE and have ARTEMIS run it on a connected Android device.

    View prompt
    In the google/artemis repo, use the ARTEMIS MCP tools to run this test on the connected Android device: <test scenario>. Expected output: a pass or fail status, screenshots of the final screen, and a list of any unexpected popups. Verify that the report states which device ran the test.

  • Give your coding agent the code graph and project memory

    Install Graphicle once and connect your coding agents to the repo's code graph and memory.

    View prompt
    In the Graphicle-AI/graphicle repository's setup, run `graphicle setup --yes` in <repo-path>, then list every file it changed. Expected output: a list of changed files and a confirmation that the Graphicle MCP server is connected. Verify by asking the agent to use graphicle to find <topic> and checking that the answer cites file names and line ranges.

  • Find leaked keys and risky MCP servers on your machine

    Scan every MCP config on a workstation and get a graded list of secrets and risky launch commands.

    View prompt
    Use the GitHub repo graygnatconsole/mcp-audit-tool to run `mcp-audit scan <config-path>` on the MCP config at <config-path>. Return the score, grade, and a list of CRITICAL and HIGH findings with their rule IDs. Verify that the report lists each server name from the config file.

  • Share one project memory across coding agents

    Install OwnMem in a repo so Claude Code, Codex, Cursor, and Gemini CLI read the same memory.

    View prompt
    In the repository grpcer/ownmem, install OwnMem into <target-repo> with the commands in its Quick start, using --hosts for the agents the team uses. Expected output: a .ownmem/ directory and host adapters created, with any one-time host steps listed. Verify that `npx ownmem recall -- "<a known project topic>"` returns a result or an abstention.

  • Make a short AI film from one character

    Create a reusable character, draw key stills, then shoot and join short clips into one film.

    View prompt
    Using the flow-mcp repo at <repo-path>, check the Flow session, create a character named <character-name>, draw three free stills with that character, and then shoot three 10-second 720p clips with max_credits set to <credit-cap> per clip. Expected output is a joined MP4 under ~/flow-mcp-out/. Verify that flow_status reports signed in and that the credit cap was not exceeded before shooting.

  • Make a narrated explainer video, approving each stage

    Build a 30 s to 2 min explainer with Claude, reviewing the brief, script, frames and final before each next stage runs.

    View prompt
    Using the repo GTKottman/mortiflix-oss, set up the studio with `npm install` and `npm link`, then run `mortiflix new explainer` for the brief <your video topic>. Run `mortiflix run` and report the gate the session stops at. Verify that the output names a stage such as script or style frames and waits for your approval.

  • Flag AI provenance marks in files Claude Code writes

    Get a PostToolUse hook that checks each file your agent writes for AI provenance marks.

    View prompt
    In the watermarks-remover repo, use the remove-ai-marks skill in Claude Code to write <file path> with <test content>. Report whether the PostToolUse hook in check mode flagged any provenance marks, and leave the file unchanged unless I ask you to clean it.

  • Make a Khan-style explainer video from one sentence

    Describe a topic to Claude Code and get a drawn-and-narrated MP4 rendered on your Mac.

    View prompt
    Using the khan-explainer skill in ~/.claude/skills/khan-explainer, write a 30-second Khan-style explainer scene about <topic> and render it to an MP4. Confirm the render prints a contact sheet path and that the MP4 plays with narration and drawing in sync.

  • Run the offline governed context demo

    Watch pinning, writes, search, fault recovery, and signed erasure run on a local kernel with no network.

    View prompt
    Clone https://github.com/halofyai/halofy, go to the kernel folder, run npm ci and npm run demo, and report the lines that show the fault result and the certificate verification. Verify that the output includes 'verifyCertificate === true' and that no API key was required.

  • Keep a coding agent working until tests pass

    Give an agent a goal and a check command, and let it loop turn by turn until the check passes.

    View prompt
    Using the Bloks repo at hamedgitty/bloks, start a /goal in the agent conversation for the project at <project-folder>, with the check pnpm test. Expected output: the goal reports done, stuck or out of turns, and the test run result. Verify that pnpm test passes in <project-folder> before you call the goal done.

  • Track what each DSH conversation costs per day

    See live cost and token totals per conversation, plus daily and period statistics inside DSH.

    View prompt
    Using the dsh-cost-meter plugin in DeepSeek Harness 0.2.0 or later, open Settings → Cost → Cost statistics and report the total cost and call count for <period>, ranked by model. Verify that today's total matches the Summary cards on the Settings page.

  • Find the cheapest listed API for a model

    Ask your agent for the lowest listed price for a model, with the site, group, unit and observation date.

    View prompt
    Using the Grandet Skill or the MCP server at https://grandet.ai/mcp, find the cheapest listed API for <model name>. Return the top three options with site, group, price, unit and observation date, and confirm that prices are shown in one currency unit only.

  • Show live agent status in a SwiftUI chat app

    Map each agent step to a matching orb so users see what the AI is doing.

    View prompt
    In the ThinkingOrbs repo (https://github.com/haplollc/ThinkingOrbs), read the README's Recipes section and add a phase-to-OrbDesign mapping for <target agent app>. Output the Swift enum, the ZStack view code and one ThinkingOrbLabel per phase. Verify that every case in the enum returns a valid OrbDesign case from the README table.

  • Boot an offline LLM chat from a USB stick

    Turn a spare x86_64 PC into a chat box that runs a local model with no operating system.

    View prompt
    Use the repo hardrave/NIGHTRUN to prepare an x86_64 USB boot stick for target device <target> (a whole-disk device such as /dev/sdX). Run the installer, confirm the device name it shows matches <target>, and report the verified media result. Verify that the installer reports the written image as verified by SHA-256 read-back before you finish.

  • Run a private coding agent on your own DGX Spark

    Install one stack and point opencode at a 27B model that never leaves the box.

    View prompt
    Use the repo hasso5703/dgx-spark-qwen38 on a DGX Spark. Run its install.sh, then send one coding prompt to the local stock Qwen3.8-27B lane through opencode. Expected output: a code answer produced by the local model with no external API call. Verify that the install reports the serving lane as proved and that the answer returns.

  • Cut Claude Code token use with one wrap command

    Run Claude Code through a local Headroom proxy to shrink tool outputs before each request.

    View prompt
    Using the repo headroomlabs-ai/headroom, install the CLI, run `headroom doctor`, then start a session with `headroom wrap claude` in the project at <project-path>. Report the output of `headroom savings` after a short session. Verify that doctor reports routing as working before you start.

  • Install skins and pick a readable theme in Claude Code

    Add the skins plugin, restart, and switch among fifteen built-in themes with /skin.

    View prompt
    In Claude Code, install the plugin from the repo hellosverre/claude-skins by running `/plugin marketplace add hellosverre/claude-skins` and then `/plugin install skins@hellosverre-mods`, restart, and run `/skin list`. Report the list of skins shown and the one currently active. Verify that tool rows now show icons and timings.

  • Auto-approve confident decisions and escalate the rest

    Use calibrated confidence to automate high-confidence typed decisions and route unclear ones to people.

    View prompt
    In the repo openJev-verdict-2.0, read reports/verdict2_base_test.json and the selective classification section of the README. Build a function that takes a decision from <input decision file> and returns either an automatic action or a human-review flag based on a confidence threshold of 0.8. Expected output: a short report listing the coverage and accuracy at that threshold, and verify that it matches the 80% coverage row of 83.44% accuracy.

  • Chat with an imported character card in DSH

    Install Agent RP on Windows, import a character card, and start a character dialogue session.

    View prompt
    In the repo hewzhew/dsh-agent-rp, follow the Windows install steps in README.md to install Agent RP, then import the character card at <path-to-card.png> through the 开始游玩 flow. Report the session name and the first line the character sends. Verify that the imported character appears in the resource library as a character card.

  • Cut Opus coding costs with automatic effort picking

    Install Effortless so each prompt gets Low, Medium or High effort without touching the Effort control.

    View prompt
    In the HeyCubit/effortless repo, install the effortless plugin into Claude Code with `claude plugin marketplace add HeyCubit/effortless` and `claude plugin install effortless@effortless`, then run `/reload-plugins`. Confirm the bar above the prompt shows an effort label such as High or Low with a model name after a few prompts.

  • Catch agent-written PHP debt before the edit lands

    Install Sloppy hooks so Claude Code, Gemini CLI or Codex checks each PHP edit and fixes new findings.

    View prompt
    In the Heyosseus/sloppy project, install the agent hooks for this repository at <project path> by running the install command for the host agent. Then make a small edit to <target PHP file> that adds a try/catch block, and confirm the agent reports any new findings from that edit. Output the list of findings and whether the agent fixed them.

  • Build a website from a plain-language description

    Describe a site in chat, watch the live preview update, and publish it to a public URL.

    View prompt
    Using the HeyPuter/builder repo's live demo at https://builder.puter.com/, describe a one-page website for <target project> in plain language, iterate on it in the live preview, and publish it. Expected output: a public URL for the published site. Verify that the URL loads and shows the content described.

  • Cut Codex and Claude Code costs with difficulty routing

    Send routine reading and fact gathering to cheaper models while hard design work stays on your primary model.

    View prompt
    Using the HiRoute repo at https://github.com/higress-group/HiRoute, set up difficulty routing for <target agent client> so routine turns use the regular model group and hard turns use the primary group. Report the published routing plan name and the model group chosen for the last three turns in a session. Verify that the sessions view shows the actual model that ran and its cost.

  • Stand up a self-hosted Agent workspace for a team

    Run the full MOVO stack with Docker Compose and finish first-run setup in the browser.

    View prompt
    Using the repo himovo/movo, clone it, run the launcher with ./movo up, and open the setup page at <setup URL>. Report the output of ./movo status and confirm the services are healthy before finishing setup.

  • Generate synthetic teacher documents as test fixtures

    Render labeled sample teacher ID cards and letters to test a document-processing pipeline.

    View prompt
    Use the Yowes MCP server in the hirotomasato/yowes repo to produce synthetic teacher documents for <country code> in a test-only folder. Call list_countries_tool and list_schools first, then generate one ID card and one employment letter as PNG files. Verify that each PNG opens and that the file names mark the documents as synthetic.

  • Build a 3D object in Blender from a text prompt

    Describe a model in plain words in the viewport chat and let the agent write and run the bpy code.

    View prompt
    Using the Blender add-on in hitkeeen/blender-ai-addon, send the text prompt <describe the target object> through the AI Copilot chat and confirm the returned Python script runs in the scene. Expected output: a new object in the viewport matching the description. Verify that the add-on reported a successful run and no error log was produced.

  • Run Claude Code on other model providers

    Route Claude Code requests through a local gateway to the provider models you configure.

    View prompt
    Work in the my-free-code repository. Set MODEL_SONNET in .env to <provider/model-id>, start the gateway with python -m my_free_code, then launch Claude Code with python -m my_free_code.cli.mfc claude. Expected output: Claude Code opens and answers a short test prompt. Verify that the gateway log shows a request routed to <provider/model-id>.

  • Install agent-ready CLIs from CLI-Hub with pip

    Use the cli-hub package to browse and install community CLIs for desktop software in one command.

    View prompt
    Using the HKUDS/CLI-Anything repo, install the CLI-Hub package with pip, then install the harness named <target-cli> with cli-hub. Report the install result and the help output of the new CLI. Verify that the command runs without an error before you finish.

  • Make a motion design video from a brief in Claude Code

    Turn brand facts and a short brief into a beat-synced motion design film, built in code by Claude Code.

    View prompt
    Using the claude-motion-design skill in Claude Code, make a short motion design launch video for <brand name> from the facts in <brand folder>. Expected output: four approved stills and a final MP4 with audio at -14 LUFS. Verify that the brand name and product facts on screen match the sourced facts.md file.

  • Run the provider-free coordination demo

    Run the synthetic demo and check the receipt for writer lease, quorum, and audit results.

    View prompt
    Clone the Hoylon/peerbridge-mcp repo and run examples\demo_workflow.py with --workspace demo-workspace and --scope demo. Report the receipt, and verify that it shows the overlapping second writer rejected and the audit chain verified.

  • Preview a React Native app on iOS and Android at once

    Run one React Native project on both simulators from a single MobileCode session.

    View prompt
    Using the MobileCode repo at https://github.com/hsandhu/mobilecode, start the iOS and Android previews for the React Native project at <project-path> through its device-preview HTTP endpoints (POST /api/device-preview/run with platform ios, then android). Report the run status for each platform. Before reporting success, confirm with GET /api/device-preview that both platforms show a running state.

  • Run a one-off agent flow from your shell

    Send one question or task to a chat flow and get the agent's answer in your terminal.

    View prompt
    Using the humanize repo (hmz), run `hmz exec -f chat -a assistant=claude/claude-opus-5:high "Summarize the purpose of the repository at <repo-path>"` from a scratch directory. Output the agent's summary as plain text. Verify that the summary names at least one file or folder from <repo-path>.

  • Turn a website into a typed CLI in one command

    Point Hycli at a site and a goal to get its reads, writes, and workflows as CLI subcommands.

    View prompt
    In the Hycli repo (github.com/Hybirdss/Hycli), run `hycli prepare <site-url> --intent "<goal>"` and then `hycli describe <site-name>`. Return the list of prepared read and write actions. Verify that no write request was sent during preparation.

  • Decompile your own N64 game with an AI agent

    Point your agent at a ROM you own and get C functions that compile to the same bytes.

    View prompt
    Using the decomp.wtf repo (i12bp8/decomp.wtf), import the N64 ROM at <path-to-your-rom> that I own, then run the agents until the live view shows matched functions. Report the number of functions matched and the number still open. Verify that every reported match is byte for byte against the ROM, and that no target assembly or build script was edited.

  • Evolve a better agent for a measurable goal

    Run several epochs of competing agents on one goal and keep the leader that scores highest on the locked benchmark.

    View prompt
    In the KADATH repository, start the runtime with ./kadath.sh and create a run for the goal <goal>. Report the best fitness and median fitness of the top five for each epoch, and confirm the approved benchmark lists the required evidence and automatic failures before the run starts.

  • Show a bug fix as a before and after recording

    Have Claude Code record the same Playwright steps on the old and new versions and review them side by side.

    View prompt
    In the claude-show-your-work repo, install the show-your-work plugin in Claude Code, then fix the bug in <target app or page> and produce a before and after Playwright recording. Expected output: both recordings playing side by side in the chat with change markers. Verify that the checks for the fixed behavior are green in the new version.

  • Redraw a figure in draw.io and export a 2000 px PNG

    Rebuild an uploaded figure on a live draw.io canvas and save an editable .drawio file.

    View prompt
    Using the scientific-illustrator plugin, connect to the live draw.io canvas and redraw the uploaded reference figure as editable shapes, connectors, and groups. Save an editable .drawio file and export a PNG preview at 2000 px width. Verify that the canvas screenshot matches the reference layout before saving.

  • Find where a Codex task spent its time

    Break one task's active time into tool, model/token, and unattributed shares to locate slow steps.

    View prompt
    Using the icesixgod/codex-trajectory repo, open the timing breakdown for the Codex task <task name or sessionId> with the show_codex_trajectory tool. Report the tool, model/token, and unattributed time shares with percentages. Verify that missing or invalid tool timing is listed separately from zero-duration events.

  • Get a green Playwright TypeScript suite in under 5 minutes

    Scaffold a running Playwright and TypeScript test project and see the smoke test pass before writing any code.

    View prompt
    In the agentic-playwright repo, run `npm create agentic-playwright <target-folder> -- --demo` from an empty <target-folder>. Expected output: the scaffold installs dependencies and a browser and the smoke test passes against the demo app. Verify the smoke test result is green before making any changes.

  • Map a paper's chapter structure through guided dialogue

    Use the /ars-plan skill to turn a rough paper idea into a chapter outline through Socratic questions.

    View prompt
    Using the repo Imbad0202/academic-research-skills installed as a Claude Code plugin, run /ars-plan on this paper description: <paper description>. Expected output: a chapter-level paper structure reached through Socratic questions. Verify that each chapter maps to a point in my own answers before accepting it.

  • Serve a looped model behind an OpenAI-style endpoint

    Host Ouro-1.4B or another supported checkpoint so apps can call a streaming completions API.

    View prompt
    In the vllm-rlt repository, follow docs/launching.md to install the project, download ByteDance/Ouro-1.4B, and start the server. Send one completions request with the prompt <your test prompt> and report the returned text. Verify that the response is non-empty and that the server log shows no errors.

  • Turn one phrase into a finished song track

    Describe a song in one sentence and let a local assistant write the prompt for ACE-Step, YuE2 or Stable Audio 3.

    View prompt
    Using the repo inikolax/remiqora, write a prompt for the idea "<song idea>" in the From an idea tab, choosing the engine <engine name>. Expected output: an editable prompt with style tags, lyrics or sections, tempo and key, plus a generated track. Verify that the track is named after the idea and appears in the engine's feed.

  • Learn why a branch change is written that way

    Step through a git branch as a guided tour that explains intent, risks and what to check.

    View prompt
    In the git repository at <path>, install diff-tour and confirm the `tour` command is on the PATH. Expected output: the path to the tour binary. Verify with `git status` that no tracked files changed.

  • Audit the security and data-handling claims in the source

    Check the published engineering against the security and data claims Inkloom makes before trusting it with account data.

    View prompt
    In the Inkloom-art/inkloom repository, find the session cookie handling, the database migration identity check and the backup restore testing code. Produce a table of each security or data claim, the file path that supports it, and any claim with no supporting code. Verify by quoting at least one file path and the relevant line for each row.

  • Turn a game idea into a playable Web game

    Describe a game in plain language and get a reviewed, playable local Web project.

    View prompt
    Using the Noobi.ai repo cloned at <path>, run `npm ci` and `npm run dev`, then submit this game brief in the workbench: <game idea>. Expect a standalone Web project in the local workspace that passed the review and playtest gate; verify the completion status shown in the workbench before reporting success.

  • Install the Lody iOS beta on iPhone to use Lody on mobile

    Get the current TestFlight build of the independent Lody iOS client on your iPhone.

    View prompt
    Using the Innei/lody-ios repo README, list the exact steps to install the current TestFlight beta on an iPhone running iOS 26 or later. Output a numbered checklist. Verify that the output says beta builds may be unstable and may break existing sessions.

  • Build a landing page from shortlisted award-winning references

    Turn 2 to 5 Awwwards sites into a cited design brief your agent can build from.

    View prompt
    Use the awwwards-mcp server to search for portfolio references, shortlist 3 sites, then call create_design_brief with the slugs and the goal "<project goal>". Expected output: a cited Markdown direction plus versioned JSON that separates shared signals from one-site outliers. Verify that every color and motion cue in your build traces back to a cited signal in the brief.

  • Get a short plain-language explanation in chat

    Ask for a brief ELI5-style answer in chat, with no file written.

    View prompt
    Using the eli5-succinct skill from isas1/skills, explain <thing> briefly in chat. Expect a short plain-language answer and no file written. Verify that no file was created.

  • Triage support tickets by urgency and owning team

    Have an agent score each ticket for urgency and pick the owning team with probabilities.

    View prompt
    Use the evaluate tool from the itsmostafa/system-one-connector repo to decide whether this ticket is urgent (noul question) and which team should own it (choice question with billing, technical and sales criteria): <ticket text>. Return the noul value and the department probabilities as JSON. Verify that the probabilities for the choice question sum to about 1.

  • Run a local 262K-context model server on a 24 GB card

    Build llama-server for an RTX 3090 and serve Qwen3.8-27B on a local OpenAI-compatible API.

    View prompt
    In the llamAmpere repo at <repo path>, build llama-server with the SM86 CMake settings and start it with the tq5_0/turbo4 command from the README. Send one chat request to http://127.0.0.1:8080 with the prompt <test prompt>, and report the reply text and the HTTP status. Verify that the server accepted a context size of 262144.

  • Get a stronger answer after Claude keeps missing

    Run /arena on a task Claude keeps getting wrong and receive one attacked, judged survivor.

    View prompt
    Install the arena skill from https://github.com/Jakeschincariol/arena-skill by copying skills/arena into ~/.claude/skills/, then run /arena --quick on <task>. Expected output: one surviving solution, the attacks it survived, its card and the round count. Verify that every sub-agent wrote only inside .arena/ before you apply any change to the project.

  • Stress-test a business idea before you launch

    Run a board review and a 100-buyer simulated panel on an idea before you spend money.

    View prompt
    Using the Jakeschincariol/founder-skill repo installed as Claude skills, run /founder-board and then /founder-consumer --quick on the idea described in <idea description>. Output the board vote, the top three objections and the reasons buyers would pass, saved under founder/. Verify that the panel answers are treated as simulated research and not as real customer evidence.

  • Turn one idea into a LinkedIn post you approve

    Write a full post from a single idea, with three hook options and a humanized draft.

    View prompt
    Install the skills from https://github.com/Jakeschincariol/linkedin-agent-skill, fill in voice.md from the three posts at <path to your posts>, then run /li-post on the idea: <your idea>. Expected output: three hook options and one full draft with no em dashes and no invented numbers. Verify that any figure you did not supply appears as {{your number}}.

  • Show your coding agent's progress on a desk robot

    Build the robot so it moves as Claude Code or Cursor reads, writes, and finishes tasks.

    View prompt
    Use the repo github.com/jamro/tiny-engineer. Run `npx -y tiny-engineer setup` for <agent name> on the machine at <project path>. Expected output: the agent integration is set up. Verify by starting a short agent task that reads one file and confirming the robot looks around.

  • Have your AI put a plan on a glass board

    Your AI assistant pins a plan or answer as a large card on your screen instead of only typing it.

    View prompt
    In the barehands repo at <path>, run bin/board.sh with a present action that titles a card with <plan title> and puts <plan text> in the body. Then run bin/board-state.sh and confirm the card title appears in the output.

  • Play Doom deathmatch while Claude runs tasks

    Install the plugin on macOS and get dropped into a shared Doom game each time Claude is busy.

    View prompt
    In the Claude Code session, install the plugin from jarrodwatts/intermission using the marketplace install command, then run /intermission. Confirm the game pane opens after Claude starts a task of a few seconds. Report whether the pane appeared and whether /intermission off stops it.

  • Back up AI coding chat history before it is lost

    Export local chats from supported AI coding tools into timestamped JSONL files you keep yourself.

    View prompt
    Using the repo jatechan/ai-data-extractor, run `python extract.py --all --merge` in the <project folder> directory. Report the number of conversation lines written to each file in extracted_data/ and confirm that all_conversations.jsonl exists. Verify that each JSONL line parses as valid JSON with a messages array.

  • Install Percho and start your first agent chat

    Download a prebuilt installer and open a visual chat with the Pi coding agent.

    View prompt
    Using the repo Jaxton07/percho, find the installer for <platform> on its Releases page and report the exact file name. Confirm the file name appears in the README download table for that platform.

  • Watch every agent's quota at the Mac notch

    Build the open-source HUD and see each agent's quota as a colour glow at the notch or a screen edge.

    View prompt
    In the agent-hud-open repository, run `make check`, `make test` and `make run`, then report whether build/Agent HUD Open.app opened. Verify that at least one agent quota shows a colour glow, and state which quota it is.

  • Run a full lakehouse platform on one machine

    Start the console, SQL, notebooks and sample Retail lakehouse on a laptop with Python only.

    View prompt
    Use the open-lakehouse-compute-fabric repo (jddevtime/open-lakehouse-compute-fabric). Install it from the README Install section, run `olcf quickstart`, and report the console address and whether the sample Retail lakehouse loads. Verify by running one SQL query against the sample lakehouse and returning the row count.

  • Score a website's readiness for AI answer engines

    Get a free 0 to 100 AI visibility score with the three gates and biggest gaps.

    View prompt
    Using the geo-score repo at jianruntech/geo-score, run the free score on <target-domain> with geo_score.py, then list the three gate checks and the top three gaps by points. Expected output: the 0 to 100 score, band and gap list. Verify that the score is reported without any API key being used.

  • Find the worth-keeping sessions in your coding history

    Import local Claude Code and Codex history and rank the sessions that hold useful task evidence.

    View prompt
    Using the EvoTrace repo at https://github.com/jinzijian/EvoTrace, install it and run /init then /candidates in the DeepSeek Harness app on my local Claude Code and Codex history. Return the top 5 candidates with task intent, repository, and missing evidence for each. Verify that the candidate list loads with no model provider configured.

  • Check your own branch before asking for review

    Run First Pass review on your branch to catch unproven problems before a teammate sees the pull request.

    View prompt
    In the <repo-name> repo, check out branch <branch-name> and run /first-pass:review with nothing after it. Expected output: a list of findings, each with its proof or marked unproven, and what the merge needs. Verify that nothing was posted to GitHub.

  • Preview a static site on localhost

    Serve a static site folder on a localhost URL with one command and stop it with Ctrl+C.

    View prompt
    In the pixelcrabs repository root, run `node packages/local-runtime/bin/static-preview.mjs <absolute-path-to-site>`. Expected output: a localhost URL printed in the terminal. Verify first that the target folder contains index.html before starting the server.

  • Make a pixel-art fly-through of a real road trip

    Turn a commute, road trip or move between cities into a scrollable pixel-art drive.

    View prompt
    Using the pixel-path skill in the jonwheatley/pixel-path repo, build a pixel path from <start place> to <end place> at the placeholders level, so no RetroDiffusion cost is incurred. Expected output: a folder containing index.html that plays the route when served statically. Verify that the folder contains index.html and that the credits line is visible on the page.

  • Give Claude Code a persistent, queryable memory

    Register the Lemmalog MCP server so Claude Code can assert facts, query them and trace each answer back to its source.

    View prompt
    Using the lemmalog MCP server in <project>, assert the facts stated in this session with lemmalog_observe, then run lemmalog_query for each decision made. Expected output: the query results for each decision, plus a lemmalog_why proof tree for one derived fact. Verify that every observed line returned no dropped-line warning.

  • Talk to a Grok Bot agent through your robot

    Flash the robot, run the Mac gateway, and say "Hi Grok" to talk with a Grok Bot agent.

    View prompt
    In the groki-bot repo, follow docs/quick-start.md to set STACKCHAN_VOICE_BACKEND=gbot and the agent name and ID in gateway/.env for <agent-name>. Report the gateway startup output and confirm that the robot responds to "Hi Grok".

  • Install Opensidian as a system package on Ubuntu

    Install the DEB package to get a menu entry, icon, and the notes app in one step.

    View prompt
    In the jpzk/opensidian repo, follow the Install table to download the DEB package for version 0.6.2 into <download-folder>, then install it with apt. Report the exact apt output line that confirms installation. Verify that running `opensidian --version` or launching it from the menu opens a window.

  • Train a small byte-level model on your own machine

    Install MLX, train the 4.5M-parameter proof of concept, and save weights locally.

    View prompt
    In the jrz97619761/test-model-thing repo, set up a venv, install MLX for this machine, and run `python main.py   train` for about 5 minutes. Report the time taken and confirm that saved weights exist on disk.

  • Find license-labeled BGM and a ducking spec for a Reel

    Install the MCP server and get ranked background tracks, licenses, and an ffmpeg mix command for one clip.

    View prompt
    Using the sonicmatch MCP server from js713-lab/sonic-match-mcp, ingest <path to clip.mp4>, analyze it for an Instagram Reel, and recommend five instrumental tracks. Then mix the top pick with ducking and return the ffmpeg command. Verify that every recommended track shows its license and attribution text before you present the result.

  • Block an AI release when eval scores regress

    Run a baseline-versus-candidate gate that exits non-zero and writes CI-readable reports.

    View prompt
    Using the EvalForge repo at https://github.com/jsdhwfmax/EvalForge, install evalforge-ci and run `evalforge gate <candidate-summary-path> --policy <policy-path> --baseline <baseline-path> --json build/evalforge-report.json`. Expected output is a pass or fail verdict and the JSON report; verify the exit code is 0 or 1 and not 2.

  • Calibrate an ASM model from a task file

    Run the full ASM workflow on plant data and get a report, calibration results and a final summary.

    View prompt
    Use the AutoWWTP-ASM repo at <repo-folder>/code/langgraph-en to run the task file <task-file> with the LLM variables already set. Expected output: a new output/task-* folder containing asm_report.md, final_result.json and midoutput/calibration.json. Verify that midoutput/sensitivity.json and midoutput/calibration.json both exist before reporting success.

  • Break a multi-episode series into acts and act outs

    Get an act-by-act breakdown with act outs for each episode of your series, using the series structure skill.

    View prompt
    Using the screenwriting-skills repo (sw-series-structure), read the series outline in <path or pasted text> and produce an act breakdown for each episode with act-out and cliffhanger placements. Verify that every episode lists a teaser or cold open and at least one act-out before returning the result.

  • Let an AI agent search and compare On Co cancer records

    Connect an agent to the On Co MCP server to search, fetch and compare cancer records with sources.

    View prompt
    Using the OnCo MCP server started with `npx -y onco-mcp` from the judegomila/OnCo repository, search for <cancer type>, fetch the treatment record for <treatment name>, and return its TL;DR, its approval status for <country>, and every primary source link. Verify that each link resolves before reporting, and state any field the record marks as no data.

  • Build a distinctive portfolio site from one line

    Get a designed, browser-checked portfolio site from a single sentence instead of a template.

    View prompt
    Using the juliobsz/skills repo, run the /awwwards skill with the brief 'make me a portfolio, my name is <name>, I work as <craft>'. Expect a built site folder, a DESIGN.md file and a list of placeholder copy. Verify that no placeholder text remains in the final HTML before you report the site as done.

  • Run the full Xyne Spaces stack on your machine

    Clone the repo and start the dashboard, backend, Claw and Claw Auth with one command.

    View prompt
    Clone https://github.com/juspay/xyne-spaces.git into <target-folder>, run `pnpm run up` from the repo root, and report which phase failed if any. Expected output: the dashboard at http://localhost:5173 responds and the backend API at http://localhost:3001 responds. Verify both URLs return a page before reporting success.

  • Turn a failing agent trace into a PR-blocking test

    Promote a production failure to a replayable case that blocks the PR that would ship it again.

    View prompt
    In the Tracely-ai repository, start the demo stack with `docker compose --profile demo up -d --build --wait`, then promote one failing trace in the UI at http://localhost:3001 to a regression case. Report the case name and confirm the case shows a fail-to-pass contract. Verify that the case appears in the cases list before finishing.

  • Run the Agent-Me twin locally with Docker Compose

    Start the web app and API on your machine with the example knowledge and no API key.

    View prompt
    Clone the jzjzzzzzzz/agent-me repository and start it from its root with Docker Compose. Report the Web application, Health, and Readiness URLs from the README table, and confirm the readiness check responds. Verify that the default configuration needs no API key before you finish.

  • Design logo concepts for a new brand with an agent

    Turn a brand brief into 8 to 12 concepts, three built in SVG, and a checkpoint to choose from.

    View prompt
    Using the logo-design skill in kaankiziltug/logo-design-skill, design logo concepts for <brand name and one-line brief>. Stop at the checkpoint and show one overview image of 8 to 12 concepts with a recommendation. Verify that the concepts were tested at 16 px and in one colour before they are shown.

  • Design a printable case from a plain description

    Describe a case or bracket in words and get a CadQuery model you can check and export for printing.

    View prompt
    In the SOMA model folder for <model name>, write a CadQuery model for <part description> in the model file, then run `soma build` to rebuild it. Report the final overall dimensions in millimeters and confirm the build finishes without errors.

  • Map the robot-use agent field from current surveys

    Read the survey papers to learn the main approaches, terms, and open problems in robot-use agents.

    View prompt
    Using the Awesome-Robot-Use-Agent README at https://github.com/kairunwen/Awesome-Robot-Use-Agent, read the Surveys section and produce a one-page summary of the categories and open problems named in the two 2026 surveys for <topic>. Verify each claim against the linked survey entry and note any claim the README does not support.

  • Cut an interview into a 60-second Reels clip

    An agent keeps chosen segments of a long interview, fits them to 60 seconds in 9:16 and exports a Reels file.

    View prompt
    Using the ffmpeg-skill repo, take <interview file> and keep 0:45-3:10 and 5:00-6:30, make it exactly 60 seconds at 9:16 for Reels, and export it. Expected output: a Reels MP4 of about 60 seconds at 1080x1920. Verify the duration and resolution with probe.py before you report it done.

  • Generate a seamless BGM loop for a game scene

    Describe a scene in one sentence and get candidate music loops sized for game BGM.

    View prompt
    Using the audio-studio MCP server from the audio-studio-mcp repo, call generate_audio for a 60-second lo-fi BGM loop at 85 BPM for a cafe scene with variations set to 3. Then call process_audio on the chosen file to make a seamless loop, normalize to -16 LUFS and export OGG. Verify that the output file exists in outputs/ with a matching .json sidecar.

  • Find a Claude Code mod that fits a task

    Ask mod-finder for mods that match a task, then compare their access before installing.

    View prompt
    Using the karanb192/awesome-claude-code-mods repo, ask mod-finder to find mods for <task>. Expected output: a short list of matching mods with their names and access details. Verify that each listed mod shows what it can read, write, run or send over the network before recommending it.

  • Keep Claude Code's cache warm during a break

    Arm a timed keepwarm window before stepping away so the next message does not pay a full cache rewrite.

    View prompt
    In the karanb192/cache-tax repo, install the cache-tax plugin, then in a warm Claude Code session run /keepwarm 90m. Report the output of /keepwarm status, including the warming window and next ping time. Verify that the window shown matches the 90 minutes you requested.

  • File your FY 2025-26 income tax return without a CA

    Turn Form 16 and AIS into a checked, regime-compared filing pack for the income tax portal.

    View prompt
    Using the itr-wala repo at <repo-path>, run the self-test, then extract income from the Form 16 and AIS in <documents-folder> into income.json for FY 2025-26. Produce the old and new regime comparison and the portal filing pack. Expected output: a comparison table and one final payable or refund figure; verify the self-test ends with OK and that TDS matches the AIS total before you report.

  • Redesign an existing HTML page in one command

    Turn a plain HTML page into a standalone, offline redesign that keeps the original meaning.

    View prompt
    Use the reimagine-it repo to redesign <path-to-page.html> by running `npx reimagine-it --auto -i <path-to-page.html> -o <output-path>/redesign.html`. Expected output: a standalone HTML file at the output path. Verify that every heading, date, and number from the source appears in the output and that the source file was not overwritten.

  • Get a second-model review of a pull request

    Run agy's reviewer persona on a PR to get severity-ranked findings before merging.

    View prompt
    Using the keli-wen/agy-staff plugin, run the reviewer persona on PR <PR number> in <repo>. Expect a severity-ranked list of findings. Verify that each finding names a file or line from the PR diff.

  • Review agent edits in Git and Diff views before committing

    Open a project, let an agent change files, then inspect staged and unstaged changes in the app before you commit.

    View prompt
    In the BetterC0de repo's Git and Diff views, open the project at <project-path> after an agent has edited it. List every staged and unstaged file with a one-line summary of each change, and flag any change you cannot explain. Verify that the list matches `git status` run in <project-path>.

  • Cut per-turn model spend in a Hermes agent

    Let Jev pick a cheaper model per turn, shadow mode first, then switch on.

    View prompt
    Install the hermes-jev-skills repo from kerpopule on this machine, set up the key, and run `jev models suggest --write`. Enable `/jev routing shadow` for the <profile> profile and report the decisions logged so far, with tier, model and confidence for each. Verify that no model switch happened while in shadow mode.

  • Design a page section live with Claude Code on a canvas

    Connect Claude Code over MCP and watch it stream a frame onto your canvas as you follow along.

    View prompt
    In the repo kgoedecke/doop, the Doop server is running on http://localhost:4300 with the MCP endpoint at /mcp. Using the doop MCP server, create one frame on the canvas <canvas-id> with a three-tier pricing section, then call get_canvas to confirm the new frame is listed. Report the frame id and the number of frames on the canvas.

  • Run the live isometric world on your own machine

    Start the Factory Yard simulation locally and watch trucks, people and robberies move in real time.

    View prompt
    Clone the repo Khalidabdi1/factory, run `npm install` and then `npm run dev` in its folder, and report the local address the dev server prints. Verify that the page shows the isometric town with moving vehicles before reporting success.

  • Get a one-screen done-or-not report after each session

    Ask "are we done?" and get a verdict on done, needed input, new debt and whether it is safe to close.

    View prompt
    In the open-steps repo at <repo-path>, use the os-done-or-not skill to report on the work just finished for <task-name>. Expected output: a one-screen report with a Fully done row, an Anything needed from you row, a New debt row and a Safe to close row. Verify that each row states a verdict and does not rely on commit hashes alone.

  • Adopt Cambium governance for a knowledge repository

    Create, validate, and approve one Cambium profile for one knowledge repository.

    View prompt
    In the Cambium repo at <repo-path>, guide me through creating and checking a candidate profile for the knowledge repository at <target-path>, then stop before adoption. Report the output of profile_onboarding_status.py and check_profile.py and list every decision still unanswered.

  • Turn repeated agent prompts into slash commands

    Install the skill, find the requests you repeat, and save each one as a short slash command.

    View prompt
    In the cli-faq-shortcuts repo, install the faq-shortcuts skill as described in its Quick start, then run /faq-shortcuts in the project at <project_path>. Expected output: a table of repeated asks with how often each was typed. Verify that each chosen shortcut has a SKILL.md under .claude/skills/ in that project.

  • Review agent edits to a Markdown document line by line

    Let the Kition Agent edit a real document, then accept or reject each addition and deletion.

    View prompt
    Using the Kition app in the workspace at <workspace path>, ask the Agent to revise the document <document name> with the goal <goal>. Confirm the document review surface lists each addition, deletion, and rewrite, and report the number of changes you kept and rejected.

  • Show an agent a bug by recording your screen and voice

    Record a screen problem while narrating and clicking, then paste the bundle into any agent.

    View prompt
    Using the Scrawl bundle at <bundle-path>, read contact-sheet.png and summary.md, open the keyframes the narration points to, and list each bug you can see with its timestamp. Verify that every timestamp you cite appears in the summary.md timeline.

  • Catch a silent model downgrade in Codex

    Install the menu bar checker and get alerted when a Codex session answers with a different model.

    View prompt
    In the kiyoakii/is-gpt-nerfed repo on macOS, install the app with the install-app.sh line from the README, then run `nerfed report`. Return the last verdict for each session listed, and check that every session shown in the menu bar panel appears in the output.

  • Run the local alert investigation stack in one command

    Start the API, worker, frontend, and Docker services to investigate alerts locally.

    View prompt
    In the kkjiangk/agent-py repository, follow the local development steps in its README to start the stack with ./scripts/start-local.sh. Report which of the frontend, API, and Alertmanager addresses responded. Verify that http://127.0.0.1:8000/docs loads before you finish.

  • Test your Android app on real phones from a script

    Write a Python or Node.js test that taps, types, and checks text on a real phone.

    View prompt
    Using the Droidline repo at https://github.com/KnifeLemon/Droidline, write a Python script that connects to the paired phone, launches <app package name>, enters <test value> into the field with id <field id>, taps <button text>, and prints the text of the element with id <result id>. Verify the printed text equals <expected text> and report pass or fail.

  • Chat with an LLM API from one browser page

    Run a full LLM chat session from two local files with no install and no dependencies.

    View prompt
    Using the Chat_UI repository at KODAMA-TECHNOLOGY/Chat_UI, download the main HTML file and the configuration file, fill in the configuration for <api-endpoint>, then open the HTML file and load the configuration. Report that the chat page loads and that one test message receives a reply from <api-endpoint>.

  • Build a project-native footer for a SaaS site

    Have an agent build a footer that reuses your primitives and links only to real destinations.

    View prompt
    Use the component-builder skill from kostja94/bricks to build the footer for <target project>. Read the existing routes, components, tokens, and framework first, reuse project primitives, and list the file paths you changed. Verify that every footer link points to a real route in the project and that keyboard access works on mobile and desktop.

  • Route support tickets by intent and urgency in Python

    Sort incoming tickets into intent categories and flag urgent ones with the Python SDK.

    View prompt
    Using the repo kraayenjon/awesome-jev and the typesafe-sdk Python package, write a script that reads each ticket in <tickets folder> and sends it to Jev with a Choice question for intent, a Noul question for urgency, and a Score question for frustration. Output one line per ticket with the intent, the urgency value, and the frustration score. Verify that every urgency value is between 0.0 and 1.0 and that every intent is one of the option keys you defined.

  • Keep a MacBook awake for a timed agent run

    Install Insomnia, then start a timed awake session so a long agent job keeps running with the lid closed.

    View prompt
    Using the repo https://github.com/krishhgg/Insomnia, install Insomnia on this Mac by following skills/install-insomnia/SKILL.md, and if a step needs my password, give me the exact Terminal command to run. Then start a session of <session-length> from the menu bar eye. Verify that ~/Applications/Insomnia.app exists and report the installed version from Settings > App.

  • Restore mosaics in a video with the Jasna app

    Use the desktop app to restore mosaics in a video on your own GPU, using the free BasicVSR++ model.

    View prompt
    Using the Jasna repo at Kruk2/jasna, download the release for <GPU and OS> from GitHub, unpack it to <local folder path with ASCII-only characters>, and start the app. Expected output: a restored video file from <input video path>. Verify that the output file plays and that only the mosaic areas differ from the original.

  • Set up an agent workspace for Triton-Ascend work

    Build or download the kit and unpack it into the folder your AI agent works in.

    View prompt
    In the triton-ascend-agent-dev-kit workspace at <working-folder>, list AGENTS.md, triton-ascend-dev-doc.md, the triton-ascend-dev-doc/ folder, and the skills/ folder. Expected output: those four items with the number of entries in skills/. Verify that skills/ contains 24 task-specific skills, as the README states.

  • Auto-name Herdr tabs from their Git branch and folder

    Install the plugin so each Herdr tab shows its folder and branch without manual renaming.

    View prompt
    In the repo kryptamine/herdr-auto-title, install the plugin into the Herdr setup on <target machine> with `herdr plugin install kryptamine/herdr-auto-title --ref v0.14.0` and then start it with `herdr plugin action invoke herdr.auto-title.restart`. Report the Herdr tab names for two tabs, one on the default branch and one on a feature branch, and confirm the feature branch name appears in its tab title.

  • Triage chat notifications into a short list of what needs you

    Andee reads your notification shade across chat apps and names the messages that need you now.

    View prompt
    Using the Andee repo at github.com/kuafuai/andee on an Android phone, set up the notification watch scene so it summarises new messages across chat apps. Expected output: a one-line list per message needing attention, name first. Verify that a stranger's link or verification code is flagged as suspicious and not opened.

  • Get safe /compact hints or automatic compaction in Pi

    Install Compact Adviser in Pi so it suggests or runs /compact at good stopping points.

    View prompt
    Install the compact-adviser package in Pi on <target machine>: run `pi install npm:compact-adviser`, set TYPESAFE_API_KEY, then run `/compact-adviser status`. Expected output: a status line reporting a key source of env, saved, or .env. Verify that the key source is not missing before reporting success.

  • Install the pentest agent locally and reach the web UI

    Clone the repo, run the install script, and open the admin setup page on localhost.

    View prompt
    Using the repo kutukam/autonomous-pentest-agent, clone it, run ./install.sh, and choose the all-Docker option. Report the URL that responds on port 8787 and confirm the /setup page loads. Verify that the process is listening with a plain HTTP request before you report success.

  • Run the bundled demo to see typed readouts in action

    Clone the repo, install PyTorch, and run the demo to see Noul, Choice, and Score answers on sample state.

    View prompt
    Clone https://github.com/kyegomez/open-jev, install torch>=2.0, and run python open_jev/main.py. Report the printed answers for the wants_refund, route, and frustration questions. Verify that the route answer is exactly one of billing, technical, or account.

  • Segment CT organs locally with AI and refine the result

    Run TotalSegmentator on a CT study inside Voxenra, then check and correct the organ masks before saving.

    View prompt
    Work in the repo l5769389/voxenra. Run `uv run voxenra`, open the CT study at <path to CT study>, and run TotalSegmentator on the liver and spleen. Report the saved file path and confirm the masks appear in the axial, coronal and sagittal views.

  • Find logic bugs in a codebase, worst first

    Run one scan to list semantic defects in your code, ranked by severity and confidence.

    View prompt
    In the perch repo at <project path>, run `perch scan` and then `perch issues`. Report the top five findings with file, line, and problem type. Verify that the output lists problems with IDs and a severity for each.

  • Talk to a Claude Code agent from your Apple Watch

    Hold the watch screen, say a request, and get your Mac's Claude Code agent to act on it.

    View prompt
    Clone https://github.com/lcoutodemos/chums into <target-folder> and follow its AGENTS.md to set up Chums on this Mac. Expected output: the hub running and a Claude Code agent started for the watch. Verify by running bin/chums-doctor from the repo and confirming it reports no failures.

  • Turn a text file into narration with an AI agent

    An agent reads a script file and saves a narrated WAV using your reference voice, with no desktop app open.

    View prompt
    Using the leemysw/yovoice repo and its Skill at skills/yovoice, read <script.txt> with <reference.wav> as the reference voice in a calm delivery and save the result as <output.wav>. Report the model used and confirm <output.wav> exists and plays back at the expected script length.

  • Continue agent tasks from your phone over Tailscale

    Expose Minke's Web UI privately to your phone through Tailscale Serve over HTTPS.

    View prompt
    Using the lencx/Minke repository README, guide the user through enabling Tailscale Serve remote access on a computer running Minke and confirm the displayed https://…ts.net address. Expected output: a short checklist with the address the phone should open. Verify that the Tailscale status on the Minke computer shows it connected to the same tailnet as the phone before reporting success.

  • Make a 25-second launch teaser with sound

    Have an agent brand, direct, score and render a launch film from a short brief.

    View prompt
    Using the cinetic skill in the Leonxlnx/cinetic repo, make a 25-second launch teaser with sound for <product name>, using the brief <one-paragraph brief>. Render a 1920x1080 MP4 and report the seed printed by pick.py. Verify that the QA audio-sync audit and the ship gate pass before you hand over the file.

  • Gate a solo refactor with a verified GATES.md ledger

    Turn a substantial change into runnable gates and re-check them before claiming done.

    View prompt
    Use the unlazy skill in the repo <repo-path> to refactor <target-module>. Write GATES.md from templates/gates-leaf.md with one runnable gate per outcome, then run node /scripts/gate-check.mjs --reverify GATES.md. Report the gate results, and verify that every gate is marked met before you say the work is complete.

  • Fetch a web page as Markdown for an AI agent

    Turn any public page into clean Markdown text that an agent can read and reason over.

    View prompt
    Using the repo lexmount/moli, install the prebuilt Moli binary and run `moli fetch --dump markdown --wait-until done <target-url>`. Output the Markdown of the page. Verify that the main body text of the page appears and is not just a blank shell.

  • Run the offline memory demo in under 15 minutes

    Install Jev Mem and watch it store observations, retrieve evidence, and print a decision trace with no API keys.

    View prompt
    Clone the Jev-Mem repository from https://github.com/libingzheren/Jev-Mem into <target-folder>, create a Python 3.11 virtual environment, install requirements.txt, and run `python -m jev_mem.demo`. Report the printed decision trace and confirm that no API keys were requested.

  • Build a product-display scene from a text brief

    Describe a product display in chat and let the assistant create the objects, camera, lights and material in Blender.

    View prompt
    Using the mcp-for-blender-pro repo, connect Blender to a chosen provider and ask the assistant to create a product-display scene with a pedestal, a camera and three lights. Report the list of objects created and confirm with viewport_screenshot or get_scene_info that the pedestal has a blue material.

  • Find every file that mentions a term in one call

    Search a whole project with ripgrep and return only the matching paths to the model.

    View prompt
    Use the aside-codemode execute_code tool to search <project folder> for the text <term> with the search content action, and return the unique file paths only. Verify that the result contains paths and no file bodies.

  • Track your brand's AI answer visibility against rivals

    Run one self-hosted pass that shows how often AI engines mention your brand versus competitors.

    View prompt
    Using the limelit-co/open repository, download the binary, start `limelit serve`, and complete the setup wizard for the domain <target-domain> with competitors <competitor-domains>. Press Run and report the visibility and share of voice per engine. Verify that each figure shows its answer count n.

  • Ask an AI to explain your sleep and training trends

    Sync your Zepp records locally, pick the dates you care about, and get a Markdown file to discuss with your AI.

    View prompt
    Using the ZeppBridge MCP server in <path to your MCP client config>, query my sleep and workout records for <date range> and summarise the changes in resting heart rate, HRV and training load. Expected output: a short written summary with the dates used. Verify that any date without samples is reported as missing, not treated as zero.

  • Ask an agent which skills are worth installing

    Give an AI agent the ranking guide so it can answer questions about top skills from current data.

    View prompt
    Read https://linkly.ai/skills/llms.txt, which describes the LinklyAI best-skills rankings. Answer this question: <your question>. Return the top three skills with their Worth-Installing Score, Cov value and per-platform counts. Verify one number against the matching CSV in data/ from the LinklyAI/best-skills repo.

  • Run a local model as the backend for a coding agent

    Serve Qwen3.8-27B on your Mac and point a coding agent at it without sending code to a hosted API.

    View prompt
    Using the lithos-metal repo at https://github.com/lithos-ai/lithos-metal, start the server with `lithos-metal serve --model nvidia/Qwen3.8-27B-NVFP4` on this Mac, then run `lithos-metal <client>` where <client> is the coding agent you want to use. Report the served model name and the first reply to a one-line test prompt. Verify that http://127.0.0.1:8000 answers before reporting success.

  • Install the plugin shop and browse DSH plugins

    Add the DSH Plugin Shop package to your dsh profile and open the shop page in the sidebar.

    View prompt
    Install the dsh-plugin-shop plugin from the LivXue/dsh-plugin-shop repo into the dsh profile <profile> using `dsh plugin --profile <profile> add [email protected]`. Report the output of `dsh plugin --profile <profile> list --depth 0` and confirm that dsh-plugin-shop is listed.

  • Explore the EAR demo in a local browser studio

    Run the offline studio to see idea trees, proof checks and rebuttal traces with no API key.

    View prompt
    Clone the repo liyingze07-svg/EffectiveAutoResearch-EAR- into <target-folder>, then run `python3 -m ear demo check` from inside it. Report the output of the check, and state whether it validated the idea trace and synthetic rebuttal wiring. Do not claim any live model result, since the demo uses authored examples.

  • Build a staged reading path on recursive self-improvement

    Turn the list's fundamentals and surveys into an ordered reading plan for a new team member.

    View prompt
    Using the awesome-rsi README at lobehub/awesome-rsi, build an ordered reading path of about 10 papers for a reader focused on <focus area>. Start from Fundamentals & Getting Started, then pick entries from the section that matches the focus. Output a numbered list with one sentence per paper. Verify that every title and link appears in the README exactly as written.

  • Connect a machine and dispatch agent work to it

    Attach a laptop, server, or cloud VM to your workspace and start agent sessions on it from the CLI.

    View prompt
    In the LodyAI/Lody repo, use the CLI to create a session in the workspace <workspace-name> on the connected machine using the agent config <agent-config> with the prompt <task>. Output the new session ID and its status from the session list command. Verify that the session appears in the output of `npx lody session list --workspace <workspace-name>`.

  • Find Jev agent projects that match a task

    Filter the catalog by category and open entry details to shortlist candidate repos.

    View prompt
    Using the Awesome Jev catalog at https://logicrw.github.io/awesome-jev-projects/en/, find entries in the <category> category that match <task>. Expected output: a list of project names with their Jev role, license, and entry details link. Verify that each license is stated as identified, custom, or undeclared before you recommend reuse.

  • Get a daily priorities summary on a schedule

    Have Endo run a standing prompt every weekday morning and read the result in chat.

    View prompt
    In the Endo repo at longsurf-ai/endo, help me set up a weekday 9 AM schedule that summarizes <my priorities source>. Expected output: a schedule entry on the Schedule page with the prompt and cron timing. Verify the next run time shown matches 9 AM on a weekday.

  • Draw a price level and get alerted when it breaks

    Install the Desktop app, draw a line or zone on a chart, and set an alert for when price crosses it.

    View prompt
    Using the OpenChart app on my Mac, help me draw a line at <price> on the <symbol> chart and set an alert for when price crosses it. Expected output: a confirmed alert on that level. Verify the alert appears in the app's alert list before you finish.

  • Compare refusal-removal methods on one eval set

    Line up weight edits, activation hooks, and cache grafts on the same refusal metrics.

    View prompt
    In the repo lordx64/phantom-kv, read the Results scoreboard and the methodology in docs/TECHNIQUE.md, then reproduce the base row for <target model> on the 60-prompt harmful and 20-prompt harmless suites with greedy decoding. Expected output: harmful and harmless refusal counts plus KL mean and max for the base model. Verify that the base counts match the README row for Qwen3-4B-Instruct-2507 before reporting any other arm.

  • Test the app on invented household data first

    Start the app with invented data to see every screen before entering real finances.

    View prompt
    In the aurelio-finance repository, start the app with the demo flag for <target OS> and report the URL or screen it opens on. Verify that the app shows an invented household and that backend/data.db is not changed by the demo start.

  • Map a math paper's main results before reading

    Get a Paper Map of structure, main-result candidates, and external reading risks before you pick a theorem.

    View prompt
    Use the papergraph-mcp repo to build a Paper Map for the paper at <paper source> in the workspace at <workspace path>. Return the main-result candidates and external reading risks as a ranked list. Verify that each candidate cites a source slice from the paper.

  • Show live space-by-space occupancy from existing cameras

    Turn existing lot cameras into a live occupancy map with per-space status updates.

    View prompt
    Using the repo lotvulture/lotvulture, set up Lot Vulture with the Docker command from its README on a Linux host, then add the camera stream <camera_rtsp_url> in the Cameras view. Report the occupancy state of each mapped space shown on the live dashboard at http://localhost:8000, and verify that the states change when a vehicle enters or leaves a mapped space.

  • Approve Claude Code permissions from the notch

    Watch Claude Code sessions in the Mac notch and allow or deny its permission requests without switching windows.

    View prompt
    Using the Louis-CFM/coucou repo, follow docs/AGENTS.md to connect Claude Code on <target machine> to the Coucou notch app. Expected output: a permission request from a Claude Code session appears in the notch with Allow, Deny and Always buttons. Verify by triggering a request that needs a file edit and confirming the buttons respond.

  • Run a coding agent on your own model

    Start a working terminal coding agent on a local or hosted model in one afternoon.

    View prompt
    Install the Raw agent harness from the repo lploc94/raw-cli, set up a configured agent on the model <model-id> at <base-url>, and run it with the task "Explain the tests in <repo-path>". Expected output: a plain-text explanation of the test files. Verify that the run finished with a model answer and no configuration error.

  • Trace which methods log a given string and who calls them

    Have an agent query an APK over MCP to map a log message to its methods and callers.

    View prompt
    Use the dexsql MCP server to open <path to APK>. Find every method that references the log message <message text>, list each caller of those methods, and show the relevant Smali. Before summarizing, confirm that each reported method name appears in the query results.

  • Check which modeling stages this machine can run

    Run the doctor check to see which stages work and which dependencies are missing.

    View prompt
    Use the Modeling Workbench repo in <tool folder> to check my environment. Read .agents/skills/cumcm-workflow/SKILL.md, run scripts/doctor.py, and list the available stages and missing dependencies. Do not install or change anything without my approval, and confirm the report names the tool folder and version.

  • Run a research question across several branches

    Turn one humanities question into a reviewed research graph and a sourced research article.

    View prompt
    Use the Luciole-Studio/Misaka-Agent repo to run /research on this question: <research question>. Expected output: a research article written into the project folder, with each citation tied to a file and page. Verify that you approved the plan before any Sister began work.

  • Check a DSH turn against its Todo before it stops

    Runs a completion check on ordinary root turns that used Todo, with up to 3 automatic supplements by default.

    View prompt
    Using the repo luobosibing2/dsh-jev-plugin, enable the Completion checks feature in a DSH profile named jev, then run one root turn that uses Todo against <target task>. Report the assessment value and whether any supplement rounds ran. Verify that a turn without Todo was skipped.

  • Reconstruct the garden shears example end to end

    Run one supervised agent session on the committed example and get a GLB and pose.json.

    View prompt
    In the agenticSTAR repo, set up the environment with ./install.sh and run the garden shears example with Claude Code using tools/run_kf.sh on examples/garden_shears/capture:0 on GPU 0. Expect runs/ to contain scene.py, mesh/object.glb and mesh/pose.json. Verify that mesh/pose.json holds per-frame poses and joint states before reporting success.

  • Gate agent merges on test output probability

    Ask AgentJev whether a test run passed and block the merge when the probability is too low.

    View prompt
    In the agent-jev repository at <repo-path>, start the coding-gates server on port 8149, send the test output in <log-file> with the boolean question 'Did the tests pass?', and return the probability of true. Verify the response by sending a log from a known failing run and confirming the probability is low.

  • Prepare and run a robot action in simulation

    Set up a robot in a 3D scene, initialize physics, and run one bounded action with feedback.

    View prompt
    In the ManfredCh/Lyapunov repo, prepare the robot <robot-name> in a paused world using the default MuJoCo engine, initialize physics, and run one bounded joint action. Report the robot's ready state and the actual world feedback after the action. Verify that the robot was initialized before any action was executed.

  • Route support tickets by department, urgency and churn risk

    Send each incoming ticket to the right team on your own server, with a confidence check for human review.

    View prompt
    Using the marcreichel/laya-php repo, add a readonly decision class for <ticket queue> with department, urgency and churn fields, and call Laya::decide on the ticket body. Report the typed result and its answerConfidence for a sample ticket, and verify that `php artisan laya:try` prints a hydrated value for that class.

  • Text a personal agent on iMessage

    Give yourself an agent with its own number that you reach by text message.

    View prompt
    In the open-instinct repo at <repo path>, run the init, dev --tunnel and connect commands from the README using phone number <phone number> and handle <handle>. Expected output: the number and the connect text printed by `pnpm instinct connect`. Verify that the printed number matches the Inkbox number assigned to the agent before sending any text.

  • Run a product launch with a GTM Engineer

    A scheduled employee drafts launch work and stages it for your review each morning.

    View prompt
    Using the ai-employees repo, install the GTM Engineer into <target folder> and confirm it builds a dashboard and schedules its routines. Expected output: a staged first set of drafts and a brief in the folder. Verify that nothing was sent, posted or submitted before you approved it.

  • Run Command Code models in the dsh web app

    Install the plugin, add your key, and pick Command Code models in the web model picker.

    View prompt
    Install the Mars-Sea/dsh-commandcode-provider plugin into the <profile> dsh profile and confirm the commandcode provider appears in the model picker. Expected output: a list of commandcode models in the picker. Verify that a test message sent with one included model returns a reply.

  • Run an authorized pentest and export the report

    Let REDCELL's agents test an approved target and export a PDF, JSON, and SARIF report.

    View prompt
    Using the repo martian56/redcell, set up the local stack and run an engagement against <target> only if written authorization for that exact scope is confirmed. Expected output: a PDF, JSON, and SARIF report exported from the session. Verify that dismissed findings are absent from the report and verified findings are marked.

  • Run coding tasks on a repo overnight, merged only if tests pass

    Queue a coding task on a real repo and let Claude agents work on it while you sleep.

    View prompt
    Use the clodfarm repo (github.com/matank001/clodfarm). Start the farm with the install script, set FARM_REPO_URL to <repo-url> and FARM_VERIFY_CMD to "pytest -q", then spawn a task with `docker exec clodfarm clodfarm spawn "<task title>" --prompt "<task description>"`. Report the output of `docker exec clodfarm clodfarm status`, and confirm the change reached main only after tests passed.

  • Run a private AI assistant on your own machine

    Start the full Ciele stack locally with one bootstrap script and sign in as the owner.

    View prompt
    In the ciele repository, run ./deploy/bootstrap.sh on <target machine>, then report the URL where the app is running and whether the database migrations finished without errors. Verify that the app responds at that URL before reporting success.

  • Align an agent on a change before any code is written

    Run a grilling session so the agent asks detailed questions before it edits your repo.

    View prompt
    In the mattpocock/skills repo's grill-with-docs workflow, interview me about the change described here: <feature description>. Expected output: a short list of resolved decisions and updated GLOSSARY.md entries or ADRs. Verify that every new term in the output appears in the glossary file.

  • Preview restart cleanup of stuck tasks before applying it

    Dry-run a SQLite task ledger, review aggregate counts, then apply timeouts and delivery closures.

    View prompt
    Using the MaxHu-xuan/task-state-guard repo, run the reconcile command with --dry-run against <ledger-path> using --active-grace-seconds 600 and --delivery-grace-seconds 600, then report the aggregate counts. Verify that the output shows dry_run true and applied false before you run any apply step.

  • Scan a Kotlin change for known footguns before merge

    Run a 32-pattern scanner over the lines your branch adds and review each flagged trap.

    View prompt
    In the kotlin-footguns skills installed in <repo path>, run the footgun-scan script against origin/main and open the trap file for every likely hit. Expected output: each hit marked confirmed or dismissed with a one-line reason. Verify that every confirmed hit names a trap file that exists in the skill directory.

  • Watch the fish brain decide in the PC simulator

    Run the desktop simulator to see the model's goals and urgencies drive a virtual tank, with no board needed.

    View prompt
    Use the mediacutlet/pocket-tank repo on GitHub. Follow the 'Try it: PC simulator' section to build and run the simulator on this machine, then report the goal and urgency the model assigns to the first fish you see. Verify that the simulator runs without error and that a state line appears for at least one fish.

  • Resume a coding task with lessons from earlier sessions

    Recall verified fixes and failed approaches from past work before a new session starts changing code.

    View prompt
    In the <project path> repository, use the MemoraX Code skill to recall prior engineering lessons about <task area> before you edit anything. List each lesson you retrieved and state which one you will apply first. Verify that the list comes from the memory search result, not from your own assumptions.

  • Run a chat that remembers facts across turns

    Serve MemT-1.0-Nano with SGLang and chat with native memory that is kept after each reply.

    View prompt
    Use the MemTensor/MemT-1.0 repo to start the MemT-1.0-Nano server from /models/<checkpoint-folder> and run the Quick Start chat example. Expected output: a reply that restates the kitten name, age and favorite food from earlier turns. Verify that the answer names facts that were given only in the first message.

  • Book tickets and run errands by iMessage

    Text your assistant a chore and it uses a cloud browser to try to finish it.

    View prompt
    Using the repo Merit-Systems/OpenInstinct, deploy it to a Vercel Pro team and confirm the Linq line is verified for <target phone number>. Expected output: a live app URL and a reply to a test iMessage from the assistant. Verify that sign-in with the phone number works before reporting success.

  • Generate reviewed agent trajectories for training data

    Run a harnessing agent over benchmark tasks and export successful trials as an SFT dataset.

    View prompt
    Using the repo metaevo-ai/harness-zero, run a reviewed rollout on the task IDs in <tasks-file> with the USPTO harness bank, then build an SFT dataset from runs/demo. Expected output: sft.jsonl containing only trials that met reward threshold 1.0. Verify that runs/demo contains trial results before you run build-sft.

  • Run a meaning-preserving final pass on a finished paper

    Have an agent make small wording edits to a draft and log every change for review.

    View prompt
    Use the game-the-llm-reviewer skill from the repository Michael-Jiahao-Zhang/game-the-llm-reviewer on <path to finished manuscript>. Read the included sections first, apply small meaning-preserving edits, and save a revised copy and changes.md. Verify that every change note entry keeps the same claims, numbers, and citations as the original.

  • Compare two web pages and cite each claim

    Ask Jevry to read two or more pages and return a comparison with citations to the pages it read.

    View prompt
    Use the repo michaelswissa/jevry: after starting it with npm run dev, ask the desktop app to compare the cancellation policies at <url-1> and <url-2> and cite each claim. Expect a comparison with citations; verify each cited sentence appears on the matching visible page.

  • Turn one recorded task into a reusable Skill

    Record a task once, analyze it with Copilot, and generate a SKILL.md an agent can run.

    View prompt
    Use the Skill Recorder repo at microsoft/skill-recorder to turn my recording of <task name> into a Skill. Expected output: a SKILL.md file with frontmatter and ordered steps that prefer native tools over UI clicks. Verify that the procedure applies to a second example of the same task before you rely on it.

  • Split your changes into clean Conventional Commits

    Use /commit to group pending edits into Conventional Commits and push, commit only, or branch.

    View prompt
    In the git repository at <repo-path>, with the better-claude commit plugin installed, run /commit and choose commit only. Expected output: one or more Conventional Commits covering the pending changes. Verify with git log that each commit message starts with a Conventional Commits type such as feat, fix or docs.

  • Debloat a slow Android TV over Wi-Fi

    Disable the manufacturer's ads, telemetry and bloat apps on your TV from your laptop, with a restore script.

    View prompt
    In the tv-home repo, run ./setup.sh, then tools/find-tv.sh to find the Android TV at <tv-ip-or-hostname> on the local network, then tools/disable.sh with a debloat list for that model from examples/. Report how many packages were disabled and the TV model from tools/venv/bin/python -I tools/tv.py --probe. Verify the output lists the disabled packages and that nothing was uninstalled.

  • Run a research project from question to draft paper

    Start a FOREST project in the browser and let it move from research goal to experiments and manuscript.

    View prompt
    Using the FOREST repository at <repo path>, install the Web workspace and start it with the project's serve command. Create a project with the research goal <research goal> and a spending budget of <budget>, then report the project ID and the first graph nodes that were created. Verify that the budget and goal appear in the project settings before any task runs.

  • See what your coding agents did and what it cost

    Install Agentacct once and review recent agent tasks, tool calls, tokens, and estimated cost on your machine.

    View prompt
    Install agentacct from https://github.com/mikehasa/agentacct on this machine using pipx, then run agentacct onboard. Report the most recent task names and their estimated costs in <project path>, and confirm that costs are marked as estimates. Verify that the Sessions view opens in agentacct tui.

  • Take an agent-built app live on your own accounts

    Detect what the app needs, approve a plan, and deploy it to your Vercel and Supabase accounts.

    View prompt
    Use the golive skill in the repo <repo-path> to detect what this app needs, then present the destination accounts and plan for Vercel hosting with Supabase before changing anything. After approval, report the live URL and the verification result, and confirm that the Vercel team and Supabase organization shown in the plan match the accounts I named.

  • Install a complete bot team from one Markdown file

    Import a team playbook, review it, and get bots, channels and paused routines in one pass.

    View prompt
    Using the OpenMausBot repo at github.com/milind-soni/OpenMausBot, import the team file at <team-md-url> through Teams → Import and list the bots, channels and connectors it would create. Expected output: a short list of those items with a note on which connections are off by default. Verify that no routine is active before you finish.

  • Run a coding agent Session through the OpenAI SDK

    Install Core and Web, then start a Codex Session from Python using the OpenAI SDK.

    View prompt
    Using the MiniMax-AI/OpenAgentCore repo, install Core and Web on <target machine> and configure a default model and Project API key. Then run the README Python quickstart with OPENAI_BASE_URL set to <API base URL> and confirm it prints a Session ID. Verify that the Session finishes and that /workspace/hello.txt exists in the Session output.

  • Build a landing page free of generic AI UI

    Install antislop and have an agent build a UI with no invented numbers or filler decoration.

    View prompt
    Using the antislop rules from the anti-slop repo (https://github.com/miqdadbadjuber/anti-slop) and the DESIGN.md in <project-folder>, build a landing page for <product-name>. Finish with the Delivery Gate PASS/FAIL report. Verify that no statistic or testimonial appears on the page unless it is provided in the brief.

  • Render comparison videos from a renderer checkpoint

    Check a renderer checkpoint visually by writing validation videos without training.

    View prompt
    Using the AgentGarten repo at <repo path>, set up the environment, download the weights listed in the README, and render the validation clips of the checkpoint at <checkpoint path> without training. Expected output: comparison videos (depth, normal, ground truth, sample) under samples/. Verify that the samples/ folder contains one video set per validation clip before reporting success.

  • Score Code as World checkpoints on QuantiPhy validation

    Run the released 4B or 9B model on QuantiPhy videos and get metrics from the official evaluator.

    View prompt
    In the Code-as-World repo at <repo_path>, run `python -m code_as_world.evaluation 4b` against the QuantiPhy validation CSV at <csv_path> and videos at <video_dir>, then run the official QuantiPhy evaluator on outputs/quantiphy. Expect a prediction CSV, a metric summary, and an outputs/quantiphy_metrics result; verify that the prediction CSV row count matches the ground-truth CSV.

  • Score a world model's generated videos with evidence trees

    Run the HarnessEval pipeline on a model's generated results and get scores backed by a saved reasoning trail.

    View prompt
    Using the HarnessEval-W repo, set up the three conda environments from docs/installation, then run harnesseval eval with --results pointing to <your-generated-results-dir>, --model-id <your-model-id>, and the matching --run-root and --manifest paths. Expect a summary.json and LEADERBOARD.md under run/harnesseval/models/<your-model-id>/evaluation. Verify that summary.json lists an overall score and per-family scores before reporting back.

  • Audit a SwiftUI or UIKit app for iPhone Duo readiness

    Find fixed-size, orientation and symmetric-inset assumptions in an iOS app before the fold breaks them.

    View prompt
    Using the iphone-duo-readiness skill from mirzaaghazadeh/iphone-duo-skills, audit <path-to-ios-app> for fixed assumptions about idiom, orientation, screen width and symmetric safe-area insets. Output a table of findings with file, line and suggested replacement, and verify that no fix branches on orientation or idiom instead of size class.

  • Turn a coding task into a verified patch

    Run a coding agent in an isolated microVM and get a patch plus gate results.

    View prompt
    In the ESF repo at <esf_path>, submit a run against <repo_url> at commit <full_sha> with the task in <task_file>, then poll `./bin/factory status <RUN_ID>` until it finishes. Report the patch location and gate results, and confirm the verification gates passed before calling the run successful.

  • Use ChatGPT Web models inside Codex without Codex quota

    Add ChatGPT Web models to Codex's native picker and keep Codex quota unused.

    View prompt
    Using the codex-chatgpt-web repo, check that the launcher is installed and that a model ending in (Web) appears in Codex's model picker for <account or workspace>. Report the model names you see and whether the browser smoke test passed. Verify that no Codex quota is used by running one short prompt on a (Web) model and confirming the reply arrives.

  • Find doc comments that contradict their TypeScript code

    Flag functions whose comments promise behaviour the body does not deliver.

    View prompt
    In the repository <repo-path>, set TYPESAFE_API_KEY, run `npx jev-lint check src --dry-run` to see the planned requests and price, then run `npx jev-lint check src`. Report each finding with file, line, rule id and score, and do not edit code until a human confirms the finding is real.

  • Route support tickets to a team on your Mac

    Pick the right team for each ticket with a local typed choice decision.

    View prompt
    In the laya-mlx repo (github.com/mizorewww/laya-mlx), write a Python script that loads aac6fef/laya-mlx and routes the ticket text in <ticket_file> to one of the teams billing, technical or sales using a choice question. Print the answers dictionary. Verify that the printed label is one of the three criteria.

  • Keep large tool output out of Claude Code's context

    Install the Claude Code plugin so sandbox tools handle big outputs instead of the chat window.

    View prompt
    In the context-mode repo, install the Claude Code plugin with the two /plugin commands in the README, then run /context-mode:ctx-doctor. Report whether every check shows [x]. Then run /context-mode:ctx-stats and report the savings ratio for the session.

  • Pick the best value product under a Toman budget

    Get ranked product picks under a price cap, with a seller grade on the top pick, from Digikala.

    View prompt
    Use the Digikala MCP server at https://digikala-mcp.mmdju.workers.dev/mcp. Call find_best_value for <product type> under <budget in Toman> and return the ranked picks with prices in Toman and product URLs. Verify that every price is in Toman and that the top pick includes a seller grade.

  • Get screened Robinhood Chain signal cards on chat

    Run five screening agents that post only 80%+ confidence call cards to Discord and Telegram.

    View prompt
    Using the noraz-agent repo, set up the bot with DRY_RUN enabled and start it in development mode. Expected output: the bot runs and posts at least one call card or a status message to the configured Discord or Telegram channel. Verify that DRY_RUN is still true in the .env file before reporting success.

  • Add your API to Monid as a connector

    Write a provider and endpoint definition and open a pull request to add your API.

    View prompt
    In the monid repo, read AGENT.md and connectors/exa/, then write a provider and one endpoint for <your API docs URL>. Run deno task check && deno task test and report whether they pass with no network.

  • Learn assembly and reversing basics for free

    Pick free courses and browser tools to start reading compiled code and assembly.

    View prompt
    Using the awesome-reverse-engineering list in the morluto/awesome-reverse-engineering repo, pick one beginner resource from its Learning section and suggest a 3-step study plan for a learner who knows basic C. Expected output: a numbered plan with one link per step. Verify that every link appears in the Learning section of the README.

  • Have an agent compute an exact matrix determinant

    Connect an MCP host to Jacobian so the agent computes exact determinants instead of estimating them.

    View prompt
    Using the Jacobian MCP server from the repo morluto/jacobian, use math.find in inspection mode on matrix.determinant.compute, then call math.run once on the exact rational matrix <matrix>. Return the determinant as an exact value. Verify that the returned value is exact and not a decimal approximation.

  • Relight a flat or weak backlit portrait

    Rebuild key light, shadows, and highlights in an existing portrait without redrawing the person.

    View prompt
    Using the xxg-portrait-rebuild-light skill from moskoo/xxg-portrait-rebuild-light, relight the portrait at <path to source image> with soft natural window light, choosing one L light code and one E exposure code. Return the edited image, and verify that the face size, position, pose, and camera view match the source.

  • Turn a four-line poem into a vertical Chinese-art video

    Make a 1080x1920 video where each line of a short poem gets its own painted scene with moving elements.

    View prompt
    Use the classical-poem-silk-video skill from https://github.com/Mr-funny/hbg-classical-poem-silk-video to make a 1080x1920 video of <poem title>, one scene per line with a fixed camera and natural motion in the painted elements. Save the final MP4 and run final_media_qa.sh on it. Verify that ffprobe.json reports 1080x1920 at 30fps with H.264 video and AAC audio.

  • Make a pressable isometric device figure in Claude.ai

    Upload the skill once, then ask for an object with buttons and get back one interactive HTML figure.

    View prompt
    Use the iso-figure skill from the MrBongoC/ai-iso-skill repo to create an isometric figure of <object with pressable parts>. Expected output: one HTML file with a numbered plate. Verify that pressing at least one part changes the display or shows a note.

  • Run several AI agents on one folder at once

    Give several jobs to different agents in one workspace and watch each one work in its own pane.

    View prompt
    Using the Nami repo at mrdainami/nami, set up the desktop app on a Mac or Windows machine and give two separate jobs to two different agents in the same folder <target-folder>. Expected output: two panes running at the same time, each with its own result. Verify that both jobs report progress and that no file outside <target-folder> was read.

  • Turn one idea into posts for several platforms from the terminal

    One source text becomes a draft for each chosen platform in a single command.

    View prompt
    Use the yominpost repo at git+https://github.com/mrlong0129/yominpost to run the yominpost run command with <your source text> for platforms x, linkedin and tiktok. Expected output: one draft per platform with a chosen format. Verify that each draft is platform-specific and that no post was published.

  • Sort a batch of texts into labels in one call

    Label short texts with plain HTTP, no key or signup, up to a thousand per request.

    View prompt
    Using the classifier.dev API from the classifier-dev repo, label each text in <input file> as bug, feature or praise by calling https://classifier.dev over plain HTTP with no key. Write the results to <output file> as CSV with the original text and the label. Verify that the number of output rows equals the number of input rows.

  • Automate a signed-in website with one saved browser profile

    Log in once in the managed Chrome profile, then let an agent run browser tasks that reuse that session.

    View prompt
    Use the nuphus-mcp server to open <site URL> in its managed browser, take a browser snapshot, and confirm the account is still signed in. Then extract <data field> from <page> and return it as a list. Verify the snapshot shows the expected account name before you extract anything.

  • Certify a model and submit it to the public registry

    Fill in the certify form, save the JSON file, and open a pull request to list the model in the registry.

    View prompt
    Work in the mrtinkz/ai-charter repository. Use the certify form at /certify to create a certification JSON file for <model name>, then copy it into src/data/certifications/ and run `npm run build`. Expected output: a new JSON file in that folder and a passing build. Verify the file appears in the /registry page after `npm run dev`.

  • Run a continuing brain that learns from live rewards

    Compose a System 1 brain and feed it observations and measured rewards in one ongoing stream.

    View prompt
    Using the Python package cadence-net (repo muellerberndt/cadence), write a loop that drives Brain.compose(inputs=4, actions=2, arousal=True) through live() calls on the toy environment at <environment file>. Expected output: a printed log of actions, rewards and last_settlement values for 200 steps. Verify that each call after the first passes the reward of the previous action.

  • Run a private coding-agent model on your own GPU

    Serve GLM-5.3-Flash locally so coding tools call it through an OpenAI- or Anthropic-compatible API.

    View prompt
    Use the GitHub repo mw00/project-maya. Set up a local GLM-5.3-Flash server on <target machine> using ./setup.sh --setup and ./maya.sh --bench, then send one OpenAI-compatible chat request with a tool definition to the local server. Expected output: the benchmark results and a valid chat response containing a tool call. Verify that the request was answered by the local server and not a remote API.

  • Install Prismantis and pick a theme for Claude Code

    Add two plugin commands, then choose one of 15 palettes or mono from drawn samples.

    View prompt
    In Claude Code, add the marketplace NahumLitvin/prismantis, install prismantis@prismantis, then run /prismantis setup and save a theme for <user name>. Expected output: a reply with a colored table header and a code header row with a copy button. Verify by asking for a short markdown table and checking that the header draws in the chosen theme color.

  • Find existing code for a service before writing it again

    Search past projects by external service tag to see whether the integration already exists.

    View prompt
    In the session-knowledge repo, call find_implementation with capability <service-name> before writing new integration code. Expect a list of existing implementations with their file paths. Verify that one returned file still exists on disk before reusing it.

  • Repair a story draft's narrative structure in Claude Code

    Diagnose and minimally fix AI tells in a story's architecture before touching word choice.

    View prompt
    Using the sepia repo, run its review operation on <chapter file path> and then its refactor operation with minimal edits. Expected output: a list of structural diagnoses followed by an edited copy of the file. Verify that no narrator states the theme outright and that the plot's causal chain is still intact.

  • Install a personal agent on your Android phone

    Install the Nano Muse APK and give the phone agent a first task that it can do on its own.

    View prompt
    In the nano-muse/nanoMuse repository, locate nanoMuse-1.0.5-arm64.apk in the v1.0.5 release, download it to <device>, and install it on an Android 8.0+ arm64 phone. Report the version the app shows after first launch, and verify it matches 1.0.5.

  • Build a scroll-driven site from one Claude Code prompt

    Install the Scroll Craft plugin in Claude Code and have it build an immersive scroll site.

    View prompt
    Using the scroll-craft skill from the nateherkai/scroll-craft repo, build a scroll-driven landing page for <target brand and product>. Follow the skill's brief, page grammar, and verification steps. Expected output: a built page in the workspace plus a contact sheet image. Verify that the verification pass reports no dead scroll and no cues stuck below full opacity.

  • Catch conflicting agent plans before code is written

    Publish each agent's planned symbol changes and get a conflict warning before either agent edits files.

    View prompt
    In the <repo path> repository, register two agents with --no-worktree and publish intents that declare the same symbol:<target> scope with different operations. Expected output: a non-empty conflicts list in the second publish result with severity, explanation, and suggestion. Verify that the conflicts array is not empty before you report that the plans clash.

  • Install GPT with Taste hooks into Codex

    Add the recipe and scoped hook reminders to Codex for multi-turn work.

    View prompt
    Clone https://github.com/NB-Corp/gpt-with-taste into <target-folder>, run `node scripts/install.mjs --hooks` from that folder, and report the files written under the active CODEX_HOME. Verify that model_instructions_file now points to the main managed prompt file and that your model, provider and AGENTS.md settings were not changed.

  • Hunt exploitable flaws in your own codebase

    Run the attacker-first scanner to get verified issues, each with an executable exploit and a proposed fix.

    View prompt
    Using the VulnHunter repo at nealbridges/VulnHunter, run the /vulnhunt skill against <target repo path>, which I am authorized to audit. Return a list of confirmed findings with each finding's entry point, sink, and exploit status. Verify that every listed finding includes an executable exploit or is labeled as lacking one.

  • Chat with a big open model Pooled across your devices

    Open one room link on your laptop and phone to run a 27B or 35B open model together, then chat with it in the tab.

    View prompt
    Using the Nehanth/pooled repository, open the room link <room-link> in two browser tabs on different devices, pick the Qwen3.6 35B MoE model, and send the message 'Hi'. Expected output: a reply from the model in the chat. Verify that both tabs list the room's devices and that the reply appears in both.

  • Generate on-model Whale-chan illustrations for a poster

    Produce identity-locked Whale-chan art in a chosen body form using the image character skill.

    View prompt
    Using the Neko3000/deepseek-whalechan repo, run the whalechan-image-character skill for <target scene, for example a standing poster>, using the form that fits that layout. Output the selected proposal and the generated WebP illustrations. Verify that the deterministic format checks and the native-res visual QA matrix both passed before reporting.

  • Offload a research task to ChatGPT Pro from Codex

    Send a research question to ChatGPT Pro and get a summary back without spending Codex quota.

    View prompt
    Using the WebGPT repo (Nhahan/WebGPT), run `webgpt p` with the research question <topic>. Expect a written summary of the findings returned to Codex. Verify that the summary answers the question and says where its claims came from.

  • Score Claude Code changes for quality during a task

    Install Jev Review in Claude Code so the agent scores its own diff at each checkpoint.

    View prompt
    Using the NiazMorshed2007/jev-review MCP tool jev_review, score my change to <target file or feature> by sending the task and focused diff. Report each applicable dimension score and confidence, then list the weakest dimensions. Verify that the tool call succeeded and that no score is missing without an applicable flag.

  • Preview which agent and model a task would use

    Run a dry run to see the agent, model, and effort the router would pick, without launching anything.

    View prompt
    In the agent-router repo, run `router run "<task description>" --dry-run` and report the Selected line, the Why line, and the Quota line from the decision card. Verify that no Herdr pane was opened and no command was started.

  • Run persistent agents on a headless server

    Install OpenBot on a VPS or home server so agents keep running when your laptop is off.

    View prompt
    In the nightly-labs/openbot repo, install the always-on server on <target-host> following docs/self-hosted-server.md. Expected output: the result of `sudo openbot login` showing a completed sign-in and a list of agents reachable from the desktop app. Verify the sign-in finished before reporting success.

  • Learn world models through nine interactive chapters

    Read the free course online to tell apart the five meanings of world model.

    View prompt
    Using the free course at https://worldmodels101.com from the NiluK/worldmodels101 repo, summarize chapter 01 and its five definitions of world model in a table with columns Definition, Predicts, and Example. Check that every example in your table appears in the course's definitions table.

  • Turn one issue into a reviewed pull request

    Send a GitHub issue through a plan, a coder, and an independent review before you approve.

    View prompt
    In the no_human repo, install the CLI, add the GitHub issue <issue-url> with --repo <local-repo-path>, and run nh review. Report the checklist items that failed with their file and line citations, and confirm whether the test status reads NOT RUN.

  • Render a first-person walkthrough MP4 from one image

    Run the Preview v1 pipeline on a first-frame image to get a clean MP4 with motion-driven video and sound.

    View prompt
    In the HelixWorld repo (NoizAI/HelixWorld), set up the Preview v1 environment as described in the README, then run ./run.sh with --image <path to first-frame PNG> and --output-dir outputs/demo. Expect a clean MP4 under outputs/demo, and verify that the file exists and that ffprobe reports a video stream and an audio stream.

  • Route support tickets to one option with a probability

    Send a customer message to one of several queues and get the probability for each queue in one call.

    View prompt
    Using the repo AnyJev (nokia-applied-research/AnyJev), load morriszjm/Tacit-9B with Tacit.from_pretrained and call decide on <customer message> with the options <queue list>. Expected output: the chosen option, a probability per option, and the route value. Verify that the probabilities sum to about 1 before routing the ticket.

  • Block a scene in 3D before paying for AI video

    Lay out the set, cast, and camera in a browser tab, then export a keyframe pack for an AI video model.

    View prompt
    Using the NomaDamas/CozyClay repo, run `npx cozyclay`, open the studio, and block a scene of <scene description> with the cast and camera shots. Export the keyframe pack for <video model>. Verify that the export includes the first and last frame, the greybox clip, the camera, and the prompt before handing it off.

  • Ask your AI assistant about your bank balances

    Run BankMCP on your own machine and ask Claude or Cursor about balances and transactions.

    View prompt
    Using the repo noskillish/bankmcp, set up BankMCP on this machine for <bank name>, then ask the assistant for the booked balance of each account. Expected output: one balance per linked account. Verify one balance against the bank's own app before trusting the answers.

  • Add runtime failure recovery to an agent loop

    Wrap each agent step with Sentry to catch invalid actions and get repair prompts.

    View prompt
    Using the Sentry repo at github.com/nuglifeleoji/Sentry, wire SentryRunner into the agent loop in <agent-repo-path>. Submit each completed agent-environment cycle with agent_step_from_parts and append repair.prompt_text to the agent messages when it is present. Report which file you changed and confirm that runner.finalize() runs in a finally block; first verify that sentry-validate configs/paper.yaml runs without error.

  • Strip AI tells from a blog post before publishing

    Run the word-level pass and scanner on an AI-drafted post so it reads like a person wrote it.

    View prompt
    Using the humanizer-stack repo at <repo path>, run python3 scripts/copy_scan.py on <draft file> and then apply the humanizer skill to fix every flagged word-level tell. Output the revised file and any remaining scanner hits. Verify that the rerun of the scanner shows no hits except lines the author marked copy-ignore.

  • Serve Nuvex network counts from an indexed Postgres store

    Run the indexer against a Postgres database, then query the read API for requests, nodes, and network counts.

    View prompt
    Work in the NuvexNetwork/nuvex-services repo. Using the .env.local values for <rpc-url> and <database-url>, apply the migrations in indexer/prisma/migrations/, start the indexer and API, then call GET /health. Report the response body and confirm it says authority: none, and state whether the program account counts returned by the API are non-empty.

  • Run the Ever Room desktop workspace on a Mac

    Clone Ever Room and start the Electron desktop app with the isolated development runtime.

    View prompt
    Using the EverRoom repository at <repo path>, follow the Quick start in README.md to install dependencies and run pnpm dev. Report whether Electron starts and what Gateway state the sidebar shows. Verify that the Gateway runs on a loopback port as the README describes.

  • Transcribe long Japanese recordings with timestamps

    Turn a Japanese meeting or interview recording into punctuated text with times, on your own machine.

    View prompt
    Using the speech.cpp repo (nyosegawa/speech.cpp), install the speech command, then run `speech asr reazonspeech-v2 --timestamps <path-to-wav>` on the target WAVE file. Expected output: Japanese text with timestamps printed to the terminal. Verify that the first line matches the opening words of the audio.

  • Build a feature from design to reviewed code

    Turn a feature idea into an approved design, a task plan, and code built one reviewed task at a time.

    View prompt
    Using the Superpowers skills from the obra/superpowers repo, take the feature described here: <feature description>. Run brainstorming, then writing-plans, then subagent-driven-development in the project at <project path>. Expected output: an approved design, a written plan, and code with a review after each task. Verify that every plan task lists exact file paths before any code is written.

  • Validate a project knowledge bundle before each commit

    Check OKF conformance, broken links, orphans, and description drift on every change.

    View prompt
    Use the okf-memory/okf-agent-memory repo to validate the knowledge bundle at <path-to-repo>/knowledge. Run the strict and drift validation, then the scorecard, and report the grade and every broken link or orphan. Verify that the command exit status is 0 before reporting the bundle as clean.

  • Find where a photo without GPS was taken

    Give an agent a photo with no location data and get back camera position, heading and an evidence image.

    View prompt
    Use the geo-sleuth skill from the Oldcircle/geo-sleuth repo to find where <path to photo> was taken. Expect a camera position with an error radius, a heading, a satellite evidence image and a confidence grade. Verify that the conclusion names the commands run and the files they produced.

  • Alert when the garage door stays open

    Get a phone notification when a camera shows the garage door open for 10 minutes.

    View prompt
    Using the VisionState repo at https://github.com/oleost/VisionState, set up a garage door state sensor for the camera <camera_entity> and a Home Assistant automation that notifies <notify_service> after the door is open for 10 minutes. Expected output: a sensor.garage_door entity and one automation YAML block. Verify that the sensor reports open, closed and halfway in the Home Assistant entity list.

  • Pick a local open model for typed decisions

    Match your hardware to a listed open decision model and check its README before running it.

    View prompt
    Using the Awesome JEV list at https://github.com/OmniJev/awesome-jev-gallery, find the Open Source entry that matches <hardware>, read its README, and report the setup steps and the output format for one typed decision. Verify that the README states a license before you recommend the entry.

  • Pick the next UI action from a screenshot

    Ask a local model whether a task is done, what to click next and how far along it is.

    View prompt
    Using the OneJev repo at https://github.com/OmniJev/OneJev, start the server with `qev serve --model OmniJev/OneJev1.6-4B --port 8000`, then send <screenshot path> with the task <task text> through the Python Client example. Return the done probability, the next-action probabilities and the progress score as JSON. Verify that the probabilities for the next-action question sum to about 1 before you act on them.

  • Run a coding agent on a local project from the desktop app

    Install the desktop app, sign in, and have the agent work on a project folder.

    View prompt
    Using the omnirush-gui desktop app on this machine, open the project at <project-path> in a new chat and ask the agent to list the failing tests and fix one. Report the files changed and confirm the chat shows each tool call the agent made.

  • Paste a clipboard image straight into a Blender scene

    Drop an image from the clipboard into the 3D View or Node Editor without saving a file first.

    View prompt
    Using the OmooLab/AnyImage add-on in Blender, paste the clipboard image <image file or description> into the 3D View with Ctrl+Shift+V. Expected output: an Image Empty in the current scene. Verify that the Image Empty exists and that the AnyImage menu opens on right-click.

  • Have an AI model complete a task on a real iPhone

    Give a plain-language goal and let a vision model tap, swipe and type on the phone until done.

    View prompt
    Using the repo onehumanbeing/esp32-iphone-agent, guide me through the four setup steps in its README for the iPhone at <device name>. Expected output: a checklist showing which of the four setup steps are complete. Verify that AssistiveTouch is on and the pointer calibration has finished before any task is started.

  • Check a package's version, license, and deps cheaply

    Get an npm package's version, license, engines, and dependencies in about 70 tokens.

    View prompt
    Use the only-cli/oc repo: run `oc npm pkg <package>` for the target package name. Expect a short block with version, license, engines, and dependencies. Verify that the package name in the output matches the target before using the data.

  • Bind non-Grok models to Grok Bot agents

    Pick a model per agent in a picker, test it live, and save so Grok Bot talks to that model natively.

    View prompt
    Using the OnlyTerp/opengrok repo, run `python setup.py` in a local clone and bind <target-model> to the agent named <agent-name> in the picker. Report the saved binding for that agent and the result of the live test. Verify the test returned a real reply from <target-model>, not an error.

  • Make a short launch video with a coding agent

    Ask Codex or Claude Code for a short film, then watch it take shape in Studio.

    View prompt
    In the openfilm/openfilm repo, run the skill install, then ask the agent to make a 20-second launch video for <product>. Expect a film folder with a film.html that opens in Studio and renders to an MP4. Verify by running `openfilm look` on the film and confirming it reports no page errors, missing fonts or missing sound files.

  • Run PACT conformance tests against a Provider

    Check that a Provider's endpoints follow the PACT spec using the bundled e2e suite.

    View prompt
    Using the openpactprotocol/openpactprotocol repo, set up the e2e conformance suite and run it against the Provider at <provider-url>. Output a list of passed and failed checks with the spec section for each failure. Verify that the suite ran against <provider-url> and not the reference Provider by checking the target in the test output.

  • Review a branch before merge and get a shareable HTML report

    Produce a bilingual REVIEW-REPORT.html with merge risk, call chains, and test gaps for a reviewer.

    View prompt
    Use the codexqa-code-reviewer skill in this repo to review the current branch against origin/main. Collect the CodexQA evidence pack (callers, blast radius, test edges) and write a bilingual REVIEW-REPORT.html. Verify that the report lists merge risk and the test gaps it found.

  • Try OpenQodex on a demo repo with planted bugs

    Run a built-in demo that scans a small repository seeded with bugs, to see the output first.

    View prompt
    In the repo at <path>, run `npx openqodex demo` and report the verdict and the number of findings printed in the receipt. Verify that a report file path is printed at the end.

  • Start the Pi coding agent faster on your machine

    Install a compiled Pi build that is ready to type sooner and uses less CPU.

    View prompt
    In the repo opensec-git/Pi-Bolt, install Pi-Bolt on this machine using the installer for this operating system, then run <project-folder> with pi-bolt. Report the output of pi-bolt --version. Verify that your Pi configuration in ~/.pi/agent is used as is.

  • Run the offline agent demo in under an hour

    Build the sparx CLI and watch a simulated AC command route through deterministic skills.

    View prompt
    Using the repo OpenSparX/MasterAgent, build it with CMake Release, run ctest, then run `./build/cli/sparx demo automotive`. Report the JSON output and whether all tests passed. Verify that the simulated AC state is read back from the same run.

  • Add a live talking face to a Python voice agent

    Stream your agent's generated audio into a portrait to show a synced avatar.

    View prompt
    Use the openspline repo (github.com/openspline/openspline) to add an avatar to the Python voice agent at <path-to-agent>. Use portrait <path-to-portrait.jpg> and pass the agent's PCM audio to avatar.stream with sample_rate=24000. Output the viewer URL and confirm the agent's audio plays once, not twice.

  • Run a coding task on a local project with your own model

    Point Vetta at a local project and get code changes with visible tool calls and approvals.

    View prompt
    Use the Open Vetta repo (openvetta/open-vetta) on the workspace at <project-path>. Ask Vetta to fix one small failing test or add one small function, approve only the commands you need, and report the list of files changed and the execution trail. Verify that the changed files match the task and that no unrequested files were modified.

  • Hand inbox triage and reports to a bot team on Mac

    Install the Bops Mac app and give a main bot, Boppy, your inbox, pipeline and reporting work.

    View prompt
    Using the OrgoAI/bops repo as the reference, list the business ops tasks a user can delegate to the Bops main bot Boppy, such as inbox, pipeline, invoices and reports. Output a short checklist of tasks and which ones require user approval before the bot sends, creates or pays. Verify that every task listed is described in the README.

  • Run a private chat app in your browser with your own key

    Start the web client on your machine and chat with any of 15 providers using your own API key.

    View prompt
    Clone the oriveo/oriveo repository, change into the web directory, run npm install and npm run dev:app, then confirm that http://localhost:3001 responds. Report the URL and the Node version used, and verify that the app asks for a provider API key on the first screen.

  • Pull a ranked list from a website with one task

    Have Scout open a site, read the page and report the items you asked for, with links.

    View prompt
    Use the outcrawl/scout repo (TypeScript, npm package @outcrawl/scout). Build a task.ts that opens <target site URL> on Outcrawl's cloud browser and reports <the items you need> with links. Print result.data and result.replayUrl. Verify that result.status is completed and that each reported item appears on the replay.

  • Remove refusals from an open model in one run

    Run Heretic on a chosen open model to get a version with fewer refusals and low KL divergence.

    View prompt
    In a Python 3.10+ environment with PyTorch 2.2+ and a GPU, install the heretic-llm package from the p-e-w/heretic repo with `pip install -U heretic-llm`, then run `heretic <model-id>` on the target model. Report the final refusal count and KL divergence values Heretic prints, and verify that the output model was saved to the location Heretic reports.

  • Run a persona bot locally and chat with it in the WebUI

    Start Cortico on your machine and talk to the reference bot in a browser console.

    View prompt
    In the Cortico repo at <path>, install dependencies and start the default deployment, then configure a model endpoint from the WebUI at http://127.0.0.1:7788/. Report the deployment name and confirm the bot sends a reply after Say hello.

  • Prepare for one company's AI engineering interview

    Use one company section to plan questions, roles and topics before your loop.

    View prompt
    Using the repo pallavi-shekhar/ai-engineering-interview-questions-company-wise, list the questions in the <company> section grouped by topic, and mark each one as having an answer link or not. Expected output: a checklist of questions with a yes or no for answer links. Verify that each answer link points to a page that exists and matches the question it sits under.

  • Generate an editable printable part from a text brief

    Turn a plain-language part description into STEP, STL, and GLB files you can open in CAD or print.

    View prompt
    Use the Multi-Agent-CAD repo (github.com/Pan-Chera/Multi-Agent-CAD). Set USER_REQUEST in multi_agent_cad/config.py to the brief <part description>, then run python -m multi_agent_cad.graph. Report the exported STEP, STL, and GLB paths and confirm the QA result before printing.

  • Stand up a governed knowledge site from a fresh project

    Create a working KSoR project with starter documents and build it locally in minutes.

    View prompt
    Use the panaversity/ksor repo to create a new project named <project-name> with `npx @panaversity/ksor@latest init <project-name>`, then run its build. Report the build line that shows documents and admitted documents, and confirm that any document with status draft is not counted as admitted.

  • Pair with a teammate on a live Claude Code task

    Share a session link so a teammate joins with shared history and both investigate the same code.

    View prompt
    In the Paradigm-Study/claude-share repo, install the shared-session plugin and start a host session that shares a link for the project at <project-path>. Output the share link and confirm the guest session at <guest-session> shows the same prompt and reply. Verify that the guest's prompt ran on the host and the guest's model was not called.

  • Serve a 7-8B model behind an OpenAI-compatible endpoint

    Deploy vLLM on one rented 24GB GPU and call it with OpenAI-style requests.

    View prompt
    Using the patchy631/time-to-first-token repo as the guide, set up vLLM on <GPU host> serving Qwen2.5-7B behind an OpenAI-compatible API. Expected output: a chat completion response from the endpoint. Verify that the response contains a non-empty assistant message.

  • Catch an app crash and read live state at the throw

    Set exception traps, reproduce the crash, and read locals and frames without a GUI.

    View prompt
    Use the Debroid CLI on the Android app <package-name>. Set an uncaught exception trap, trigger the crash path <steps-to-reproduce>, and run `debroid poll --with-stacktrace` followed by `debroid pause-state`. Return the exception class, the frame where it was thrown, and the local values at that point as JSON. Verify that the exception class matches the crash in the bug report before proposing a fix.

  • Run a persistent task agent on your Mac

    Install Noodle, connect your AI account and give a bot a recurring task with its own workspace.

    View prompt
    Using the Noodle project at github.com/pdparchitect/noodle, guide a user through installing Noodle on macOS 26 and creating one bot for <task description>. Expected output: a bot named <bot name> with a backstory and one task started. Verify that the bot's workspace shows the files you attached.

  • Install the native Herdr client and open your sessions

    Get a native window onto your local Herdr daemon in a few copy-paste commands.

    View prompt
    Using the penso/herdr-gpui README, install the herdr-gpui client on <target-platform> with the matching command from the Install section, after confirming a Herdr daemon is already installed. Report the install command you ran and the version reported by the app. Verify that the app starts without installing or upgrading the Herdr daemon.

  • Run a local Codex agent on a Strix Halo box

    Serve Qwen3.8-Flash-Next locally and point Codex at it through the Responses API.

    View prompt
    Using the repo peonist-ai/halogen-flash-server, configure Codex on <target machine> to use the local halogen server on port 8731, following docs/codex.md. Expected output: Codex completes a short test task against the local model and returns an answer. Verify that the server responds on port 8731 before running the test.

  • Audit past agent sessions without changing any config

    Scan existing agent session artifacts on a machine to list agents and surface findings.

    View prompt
    Use the repo perplexityai/numbat. Run `numbat agents` and then `numbat scan --agent <agent-name>` on this machine, and save the NDJSON output to a file. Report the number of findings and their rule_id values. Verify that the output contains no complete raw transcript and that secret values are redacted.

  • Run agent-written code in an isolated sandbox

    Create a sandbox, run a command in it, and collect its output over the HTTP API.

    View prompt
    Using the repo perplexityai/SPACE, follow docs/first-sandbox.md against a local deployment at <SPACE API URL> to run <command> in a new sandbox. Report the command output and exit result. Verify that the sandbox is deleted after the run.

  • Let a second model approve routine bash and write requests

    Install the reviewer so bash and write approvals get AI verdicts while other tools still go to a human.

    View prompt
    Using the repo PerryLink/dsh-auto-review, install it into the DeepSeek Harness profile <profile-name> with the git channel command from its README, then run dsh --profile <profile-name> --dump-config and confirm an entry with id auto-review is listed. Report the matching config lines and the output of /auto-review status. Verify that the toolsPolicy shows bash and write set to ai, and that edit is not set to ai unless the user asked for it.

  • Map an industry chain with sourced values and gap list

    Build an upstream, midstream, and downstream chain map where every number carries a source and missing data is listed.

    View prompt
    Using the dsh-industry-research plugin in DeepSeek Harness, call industry_map for the industry <industry-name> with a chain of nodes and edges. Expect a saved chain.json and a gap list. Verify that every metric with a value has a sourceRef, and that the tool reports the gaps rather than filling them.

  • Seal a research report with byte-checked claims

    Bind each claim to saved source snapshots and seal a report whose manifest hash anyone can recompute.

    View prompt
    Using the dsh-research-report plugin in DeepSeek Harness, register the source at <source path or URL> with evidence_add, then seal a report on <topic> whose claims bind to that evidence. Expected output: a seal hash and a claim count line. Verify that every claim you wrote shows a verdict and that no claim with an empty evidenceIds list is marked verified.

  • Route support tickets with typed Jev answers

    Ask Jev yes/no and choice questions about a ticket and act only on confident answers.

    View prompt
    In the PerryLink/jevcore repo, write a Node script that asks Jev a noul question ('Does this convey urgency?') and a choice question over the ticket text in <ticket file>. Expected output: the probability and confidence for each answer. Verify that the startup line reports egress=OFF and provider=mock, so no network call was made.

  • Edit an AI-written Markdown plan and send feedback in one batch

    Mark up a Markdown plan in the browser and send all edits and comments to your agent at once.

    View prompt
    Install the human-review skill from the petergyang/human-review repo, then open <path-to-markdown-file> with /human-review. After I click Send, confirm the agent applied every edit and comment to the Markdown source and report any change it could not make.

  • Triage a slow PostgreSQL database in ten seconds

    Run one read-only health check and get ranked findings for a database you do not own.

    View prompt
    Using the pgbot tool from the pgrundev/pgbot repository, run `pgbot inspect --json` against the database whose connection string is in <target-env-var>. Report the CRITICAL and WARNING findings and the health score. Verify that the JSON contract version reported is 1.5.0 before you trust the findings.

  • Walk a real San Francisco plaza in a browser

    Explore a generated Union Square build and its walkthrough route without installing a game engine.

    View prompt
    Using the repo PhiloLabs/fable51-worlds, open the union-square-sf build in a browser and check the five walkthrough scenes listed in the README (aerial, plaza, Nintendo, lower level, Apple). Expected output: a pass or fail list for each scene. Verify that every scene named in the README is reachable in the build.

  • Launch a business website from a starter site

    Install Kaleta on your hosting and publish a working business site from a starter in under an hour.

    View prompt
    Using the kaletacms repository on GitHub, guide me through installing Kaleta on <hosting-domain> with PHP 8.3 or newer. Report the install.php URL and the starter site I chose, then confirm the home page loads over HTTPS.

  • Remove AI tone from a work email without changing its commitments

    Rewrite an AI-drafted sales, support or HR message in a plain voice with every fact kept.

    View prompt
    Using the work-humanizer skill from the phuryn/work-humanizer repo, rewrite the AI-drafted email in <draft-file> in a plain human voice. Output the rewrite and the sentence-by-sentence fact audit. Verify that every price, date, offer, condition and caveat in the rewrite matches the original in meaning and strength.

  • Judge job postings against your resume

    Have your coding agent score matching postings against your resume and preferences.

    View prompt
    Using the pinloop-cli repo, search Pinloop for postings matching <target role and location>, then judge each match against my resume and preference files. Expected output: a ranked shortlist with a short reason for each score. Verify that each shortlisted posting links back to its original listing.

  • Run a coding agent on a real project from one desktop app

    Bring Codex, Claude Code, or Kimi into a project through ACP and review its plans and file changes.

    View prompt
    Using the Pinvou/pinvou-agent repo, start the desktop app with run-dev.sh, open Code mode, and attach the project at <project-path> to a Codex or Claude Code session over ACP. Expected output: a session bound to that folder that shows a plan and at least one file change. Verify that the session still appears after restarting the app.

  • Publish an agent's design doc for full-screen review

    Let Claude Code upload an HTML design doc and return a review link you can comment on.

    View prompt
    In the plannotator/artifact-server repo setup, use the Artifact Server Skill to upload the HTML file at <path-to-design-doc.html> as a new artifact. Expected output: the full-screen review link returned first. Verify that the link opens and shows the uploaded document.

  • Turn data on a logged-in page into an editable sheet

    Select the data on a live page, describe the result, and get a sheet artifact you can edit.

    View prompt
    Using the Paw Work extension in the PawWork repo, load the unpacked extension, select the data on <target page URL> in the side panel, and ask for an editable sheet artifact with the selected fields. Verify that the row count in the sheet matches the rows visible on the page.

  • Set up gates so agent code stays correct

    Generate contracts, gates, and ratchets for a repo so AI-written code is checked before commit.

    View prompt
    In the repo at <repo-path>, run `/gap-trap setup` after confirming gap-trap is installed with `npx skills add pliablepixels/gap-trap`. Report the list of contracts and gates the skill proposed and the commit it created. Verify that `git status` is clean and that no push happened.

  • Verify a bug fix by reading live component state

    Let an agent read and check a running app's component state after a fix, without editing source files.

    View prompt
    Using the medula MCP tools from the medula repo, connect to the running dev server for <app-port> and list the components on the current page with their state. Expected output: a list of components with their state values. Verify that the values match what the open browser tab shows.

  • Continue a Herdr workspace on your phone

    Start work on a computer, then pick up the same Herdr workspace and sessions from a phone through Roamgate.

    View prompt
    Using the powerfooI/roamgate README, set up Roamgate on <target machine> so a phone can reach the running Herdr workspace. Run `roamgate url --qr` and report the URL and the QR output. Verify that the URL loads the workspace list after login before reporting success.

  • Chat with an 80B model on a 32 GB laptop

    Install Janas-LLM on Linux and chat with a model larger than the laptop's RAM, offline after download.

    View prompt
    In the janas repo at <install-folder>, run ./janas-chat, choose the Qwen3-Next-80B-A3B model, and ask it one short question. Report the reply text and the tokens-per-second figure if shown. Verify that the process finished without the desktop becoming unresponsive.

  • Pick the Jev integration path that fits your stack

    Match your framework or platform to a documented Jev access route and its migration caveats.

    View prompt
    Using the Promethe-us/awesome-jev README, find the integration row that matches <my stack>, and return the route name, model identifier, and linked official doc. Verify that the README notes the response schema differs from the native Choice, Score, and Noul primitives before you recommend it.

  • Check an LLM answer before you act on it

    Use the five-unit core route to write a bounded request and inspect the model's answer.

    View prompt
    Using the Prysai-LLM-Playbook repository, read book/routes/llm-foundation-core-v1-EN.md and write a bounded task card for <task>. The expected output is a card with goal, context, allowed help, limits, check, and stop condition. Verify that every limit is stated before any request is sent.

  • Classify images with a pretrained Vision HOPE model

    Load a Vision HOPE ImageNet-1K checkpoint and get 1000-class logits for your own images.

    View prompt
    Using the VisionHOPE repo (PSRben/VisionHOPE), install the classification requirements, download visionhope_small.pth into weights/, and load it with create_model. Run one forward pass on <image path> resized to 224 x 224 and report the top-5 ImageNet class indices. Verify the output tensor has shape [1, 1000].

  • Chat with several AI models for free, no signup

    Open the hosted Ptero chat and talk to models such as DeepSeek V4 or Llama 3.3 without an account.

    View prompt
    Using the Ptero repo (Ptero-ai/Ptero) as the reference, open https://ptero.pro, choose the model named <model name> from the dropdown, and send the prompt <your prompt>. Expected output: a model reply shown in the chat window. Verify that the selected model name appears in the interface before you accept the reply.

  • See a builder and verifier agent work one rule

    Run the guided tour to watch a coordinator, builder and verifier handle one approved rule end to end.

    View prompt
    In the repo <path>, install Pullboard with `npm i -g pullboard` and run `pullboard tour`. Report the final accepted verdict and the reason the verifier gave. Verify that the greeting for a blank name now returns "world" in the test the builder added.

  • Connect a hosted Linear MCP server to Claude Code

    Add a remote MCP server to Claude Code with one command and no local install.

    View prompt
    Using the repo awesome-remote-mcp-servers, add the remote Linear MCP server to Claude Code with the README command, then ask it to list <my open Linear issues>. Expected output: a list of issue titles and IDs. Verify the Linear server appears as connected before reporting.

  • Review a Git diff in a script or CI job

    Pipe a diff into a non-interactive DSCODE turn and get the reply on stdout with a meaningful exit code.

    View prompt
    Using the repo qiz029/dscode, run `git diff | dscode exec "review this"` inside <repo path> and return the reply and the exit code. Verify that the exit code is 0 and that the reply text was written to stdout, not stderr.

  • See remaining limits for all your AI coding tools

    Put one ring per AI coding service on the screen edge and read what is left without opening usage pages.

    View prompt
    Install Pulse from https://github.com/qunqin24/Pulse by downloading the latest Pulse-x.y.z.dmg from Releases into <download-folder> and moving Pulse.app to /Applications. Confirm that /Applications/Pulse.app exists and report its version. Verify the app launches and that the service chooser appears on first run.

  • Find Figure 1 layout references for a paper

    Browse and filter top-conference teaser figures to pick layouts for your own Figure 1.

    View prompt
    Using the gallery at https://qwdwqfwq.github.io/topconf-paper-figure-gallery/, find figures tagged <visual pattern> that relate to <paper topic>. Return a list of at most five entries with title, venue, year and source paper link. Verify that each link opens the source paper.

  • Delegate coding tasks to an Agent by voice

    Speak tasks to a backend coding Agent and hear results return to the same conversation.

    View prompt
    Use the repo QwenAudio/qwen-audio-agent to set up a voice session that delegates <task description> to a backend coding Agent. Confirm the Gateway starts and the TUI connects, then report the task status returned in the conversation. Verify that the Gateway log shows the task was created before reporting success.

  • Run a coding session that asks only about risky steps

    Install Mu and let the judge approve routine commands, asking you only about the rest.

    View prompt
    Install the mu-agent package for the mu coding agent (github.com/qybaihe/mu) with `npm i -g mu-agent`, run `mu setup`, then start `mu` in <project path>. Expected output: a running session in that folder. Verify that `mu ledger` lists at least one judge verdict with its probabilities and timing after a short task.

  • Draw the real data model from a Prisma schema

    Turn a Prisma schema into a validated ERD that shows the tables that actually ship.

    View prompt
    In the repo <repo path>, import prisma/schema.prisma into docs/db.erd.json with vibeX, validate it, and render docs/db.erd.html. Report the table count and any validation errors. Verify that every foreign key in the schema appears as a relation in the ERD.

  • Switch between Claude Code accounts in one click

    Save each Claude Code login once, then swap the live session from the macOS menu bar.

    View prompt
    Using the Janus repo at RamitVishwakarma/Janus, explain how to save the Claude Code account currently signed in on this Mac and switch to <target account name>. Report the list of saved accounts and which one is live. Verify that the live account in the menu bar matches the account you switched to.

  • Flash a wake-word voice assistant onto an ESP32

    Flash the QuickSilver preset so the gadget answers out loud after you say Hi, ESP.

    View prompt
    In the esp32-thinks repo, run the quicksilver preset setup against the SDK at <sdk-path> on serial port <port>, then report whether the build and flash finished without errors. Verify that the device answers after you say Hi, ESP or press the knob.

  • Extract a website's design system from its live pages

    Pull colors, type, spacing and component styles from a site's computed styles with Dembrandt.

    View prompt
    Use the dembrandt project from the Awesome-REA tools list to extract the design system of <target-site-url>, which I own or have permission to analyze. Return the color roles, typography, spacing and button and input styles as a short report. Verify that each color value matches a computed style on the live page.

  • Scan a room from phone video and query it

    Upload a phone video and ask your AI assistant what objects are in the room and how big it is.

    View prompt
    In the openreality repo's MCP tools, upload <video path>, reconstruct it, then list the objects in the resulting scene and report the room size. Verify that the answer says whether dimensions are metric or relative, because the README states numbers are only called metres after calibration.

  • Turn a training config into a source-linked diagram

    Ask your assistant to map data, model, losses and validation as a clickable diagram.

    View prompt
    Using the MLView repo at <mlview-checkout>, install the mlview skill into <target-project> and ask the assistant to explain the training config in <target-project>. Expect a *.mlview.json file that opens as a diagram. Verify that the diagram lists unresolved items and that its cited files are reported as unchanged.

  • Ask a teammate's coding agent a question directly

    Message a specific teammate's open agent session and get the answer back in your terminal.

    View prompt
    In the reason-machines/reason-network repo, install Reason Network, run `reason-network who`, and send <teammate>/<session> the question "did the token format change?". Expected output: the session list followed by the teammate's reply after running `reason-network listen --as terminal`. Verify that the target session appears as idle or busy in the `who` output before sending.

  • Route support tickets to teams with probabilities

    Send each ticket to a team, an urgency level and a churn-risk flag in one model call.

    View prompt
    In the receptron/laya repo, write a Node.js script that loads Laya with Laya.load() and calls systemOne on the ticket in <ticket-json-file>, asking which team should handle it with choice options billing, support and sales, plus an urgency score and a churn_risk noul question. Expected output: a printed JSON object with the chosen team, its probability, the urgency score and the churn P(true). Verify that the department probabilities sum to about 1.

  • Triage an unknown binary in one desktop session

    Open a sample and read its hashes, hardening flags, libraries and function counts before deeper work.

    View prompt
    Use the Recurse repo at <repo path> to triage the binary at <target path>. Report the SHA256, the hardening flags and the linked libraries from the Recon page. Expected output: a short written summary. Verify that the SHA256 matches a local sha256sum of the file.

  • Find where to change code without reading the repo

    Ask a question about a feature and get a ranked list of the code to touch.

    View prompt
    Use ripwire on the repo at <path>. Run ripwire . --for="<task description>" and list the top ranked symbols and files it returns. Verify that each named file exists in the repo before you open it.

  • Make a launch video from a plain-text brief

    Describe a launch video in chat and get an exported MP4 built by your own coding agent.

    View prompt
    Using the Remocn Studio project at <project folder>, describe a 30-second launch video for <product name> and let the studio's agent build it through its seven stages. Expect an exported MP4 and a docs folder containing script.md and review.md. Verify that review.md lists every note with evidence before you treat the video as done.

  • Get typed LLM decisions from text on your own machine

    Run a local decision API and get yes/no, choice and score answers as JSON with probabilities.

    View prompt
    In the rizzo-flow repo, start the server with `uv run rizzo serve`, then POST a JSON body with the state from <path-to-text-file> and one yes/no question to http://127.0.0.1:8017/v1/systemone using model rizzo-latest. Return the typed decision and its probabilities. Verify that the response contains a probability for each option.

  • Serve a local chat API on a machine with no network

    Build the engines and run an OpenAI-style chat endpoint on one NVIDIA GPU with no downloads at build or start.

    View prompt
    In the UnbiasedStrata repo at <repo-path>, run make build and then make test, and report whether the test suite passed. Then start unbiased-strata with the model at <model-path> on port 18091 and confirm that GET /health returns a success response.

  • Deploy a private personal AI agent in one command

    Install Talorys into your own Cloudflare account and sign in from any device.

    View prompt
    In the rociiu/talorys repo, run `npx create-talorys@latest` in <target-folder> and follow the prompts for the Cloudflare account and owner password. Report the pages.dev URL the installer prints. Verify by opening that URL and confirming the password screen loads.

  • Learn AI engineering lesson by lesson in your agent

    Install the skills so a coding agent quizzes you, teaches one lesson at a time, and tracks progress.

    View prompt
    Using the repo rohitg00/ai-engineering-from-scratch, install the skills with npx skills add and run the start-learning skill for <target host>. Expected output: a LEARNING.md file with a phase-by-phase plan. Verify that LEARNING.md exists and names a starting phase.

  • Try a duck goal in the simulator with no robot

    Run a goal like find the ball and kick it on a simulated Microduck with no hardware.

    View prompt
    Using the rokbenko/quackd repo, install quackd[microduck], register a simulated Microduck under the name <robot-name>, then run quackd run --goal "Find the ball and kick it" against it. Report the final status and the list of skills the model called. Verify that the run ends with success rather than an abort.

  • Extract invoice fields into a validated schema

    Turn invoice PDFs into Pydantic-validated fields using one pipeline call or one CLI command.

    View prompt
    Using the py-idp repo, run the idp CLI on <path to invoice PDF> with --schema Invoice and --backend openai, then print the extracted fields. Verify that the output is a dict whose keys match the Invoice schema fields and that no validation errors are reported.

  • Run a code review loop until no merge blockers remain

    Have Rome work through P1 and P2 review comments until a pull request has no merge blockers left.

    View prompt
    Using the rome-os/rome instance at http://localhost:7663, ask Rome to fix all P1 and P2 review comments on <pull-request-url> until no merge blockers remain. Expected output: a summary of the changes made and any blockers still open. Verify on the pull request that each addressed comment is resolved before reporting completion.

  • Run a local Grok agent on a project from a desktop app

    Install the desktop workbench, connect your Grok Build CLI, and work on a project folder with approval prompts.

    View prompt
    Using the Grok App repo (https://github.com/RongleCat/grok-app), set up the desktop workbench and open the project at <project-path> as a trusted workspace in Ask permission mode. Expected output: a running agent session tied to that project. Verify that the grok CLI version is 0.2.112 or newer before starting.

  • Keep long builds and agents running after you close the window

    Detach from Think Term and reattach later to the same shells, builds, and agent tasks.

    View prompt
    Using the RoversX/ThinkTerm repo, start a long-running build in a pane of a ThinkTerm session on <target machine>, detach the client, then reattach with `thinkterm tui`. Expected output: the build log continues from where it was before detaching. Verify that the process is still running after the client disconnects.

  • Re-count an AI support bill against the vendor rule

    Run the free CLI on a billing export to see overcharge and undercharge findings, unsettled rows and dollar variance.

    View prompt
    Using the AgentMeasure repo, run `agentmeasure recount --export <export.csv> --vendor <vendor>` on the file at <export.csv> and report the overcharge, undercharge, net variance and count of cannot settle rows. Verify that rows without enough evidence are excluded from the claim rather than zeroed.

  • Connect Codex to Ruflo's MCP server

    Give Codex Ruflo's MCP tools so it can use Ruflo's agent coordination from your project.

    View prompt
    Using the repo ruvnet/ruflo, set up the Ruflo MCP server for <target client> in the project at <project path>. Expected output: the MCP server entry with command npx and arguments ["-y", "ruflo@latest", "mcp", "start"]. Verify that the client lists Ruflo tools before reporting success.

  • Write a precise Veo 3 video prompt in Claude Code

    Turn a rough scene idea into one English prompt with shot, lighting, camera move and grade.

    View prompt
    Using the cinematic-video-prompt skill from the repo Rylaispirit/cinematic-video-prompt-skill, write one English text-to-video prompt for <target scene> for <target model, such as Veo 3 or Kling>. Return the prompt in a code block in the formula order of shot, subject, action, setting, lighting, camera movement, style, mood, technical, plus a one-line explanation. Verify the prompt contains exactly one camera movement and one main action.

  • Run a full SEO audit from your own Search Console data

    Get indexation issues, CTR anomalies, decaying pages and quick wins from your real GSC and GA4 data.

    View prompt
    Using the open-seo-mcp-skills seo-audit skill through the Ryze MCP, run a full site audit on <target-domain> covering indexation, CTR anomalies, decaying pages and quick wins. Return a ranked list of findings with the data source for each. Verify that every figure comes from the connected Search Console or GA4 account, not an estimate.

  • Run an authorized pentest workspace on your own machine

    Start a local AI agent workspace in Pentest Mode for an authorized engagement.

    View prompt
    Clone https://github.com/S1N6H/pentest-harness, run `pnpm install`, `pnpm build`, and `pnpm dsh web`, then confirm http://127.0.0.1:2323 returns a page. Report the URL and the output of the start command. Only use this workspace against <target> after written authorization for that target is confirmed.

  • Build and script a Roblox feature with an AI agent

    Describe a feature in Roqer and the agent builds and scripts it in your Studio place.

    View prompt
    Using the Roqer repo at <repo path>, start the desktop app with `npm run start:desktop`, open the place <place name> in Roblox Studio, and ask the agent to build <feature description>. Expected output: the instances and scripts created or changed, with each script diff listed. Verify that a script edit was not refused because the script changed after the agent read it.

  • Arrange windows and open apps by voice on your Mac

    Hold a shortcut, say what you need, and Atticus moves windows and opens apps across your displays.

    View prompt
    Using the repo SaarthurR/atticus-mac, set up Atticus on a Mac so that the request "<your layout request>" arranges the named windows across the displays. Expected output: the windows are placed as described and the second run of the same request finishes faster. Verify by checking that the windows match the layout after one repeat of the request.

  • Ask Constitution questions and get cited answers

    Run the local demo and ask questions in English or Urdu, getting answers that cite the source page.

    View prompt
    Clone the repo salikhussain71-code/PAKGOV-RAG-project, install its demo requirements, and start app/demo/app.py on port 8501. Ask the demo the question <question in English or Urdu> and report the answer, its status, and its [Source: Constitution.pdf p.X] citation. Verify that the cited page actually contains the answer text before reporting it.

  • Find the right fix for a failing Harness run

    Route a failing DeepSeek Harness run to the guide that matches its failure boundary.

    View prompt
    Using the DeepSeek Harness Handbook (sandbaseai/deepseek-harness-handbook), take this symptom: <symptom>. Use the Interactive Failure Router and the docs/en/troubleshooting/ folder to name the failure boundary and the single guide to follow. Output the guide path, the first evidence to collect, and one check that would show the guide does not match my runtime.

  • Generate a project image from a text prompt

    Create an icon, mockup, or hero image with gpt-image-2 and save it to your repo.

    View prompt
    In the Sateezg/codex-bridge plugin setup, run codex-imagegen with the prompt "<prompt>" and save the result to <output-path>.png. Report the absolute path the wrapper prints. Verify that the file exists and opens as a PNG before reporting success.

  • Run Mac actions by voice without a screenshot

    Hold a shortcut, say a command, and Jev performs the matching action in the front app.

    View prompt
    Using the jev-use repo on this Mac, run `scripts/say.sh "<command>"` with the command text in place of <command>, for example "Open Finder". Expect the app to perform the action and report DONE, BLOCKED or WAIT. Verify by running `log show --predicate 'subsystem == "local.jev-use"' --last 10m --info` and confirming the logged result matches the expected action.

  • Run the hello task to check your install

    Confirm agent-env works on your machine with the built-in hello task.

    View prompt
    In the scaleapi/agentenv-framework repo, run `agent-env run hello` from <project folder>, then run `agent-env --version`. Report the output of both commands and whether the hello task completed. Verify that the version printed matches the version you installed.

  • Build the Hatoba desktop app from source

    Compile and run the open-source SSH client on your own machine instead of using a release build.

    View prompt
    Clone the scarletkc/Hatoba repo, run `pnpm install` and then `pnpm tauri dev` in the cloned folder, and report whether the app window opens. Verify that the Rust and Node.js versions meet the README requirements before starting.

  • Check project docs against a shared Markdown convention

    Run Seiso on a repo to list stable-rule findings in its Markdown docs.

    View prompt
    In the repository at <repo path>, run `seiso check` from the repository root. Report the total number of findings and the file path and rule name of the first finding. Verify that the report only lists stable rules, since preview rules are not run by default.

  • Watch context, cost and rate limits during a session

    Keep the main panel open to see context fill, compactions, cost and rate-limit resets as you work.

    View prompt
    In Claude Code 2.1.287 or later, install the scasella/claude-flightdeck plugin from its marketplace, run /reload-plugins and /flightdeck, then report the model, context percentage, compaction count and cost shown in the main panel. Verify the main panel appears before reporting.

  • Generate a PBR material set and apply it to a mesh

    Create a saved PBR texture set with Scenario and assign it to one chosen material slot.

    View prompt
    Using the scenario-labs/blender-plugin extension in Blender 5.0 or later, generate a saved PBR texture set for the mesh named <mesh name> and apply it only to the material slot <slot name>. Report the saved set name and the CU estimate shown before Generate. Verify that the other material slots on the mesh are unchanged.

  • Generate a matching set of game sprites and icons

    Have an agent produce sprites, icons, and props in one style, with transparent backgrounds, through Scenario.

    View prompt
    Using the scenario-labs/skills repo, generate a batch of sprites and icons from the list in <item-list-file>, keeping one art style and transparent backgrounds. Save the files to <output-folder> and report how many succeeded. Verify that each PNG opens and has an alpha channel.

  • Find what was agreed in past meetings by asking your agent

    Ask your agent a question and get the meeting, the decision, and a link back to the exact line.

    View prompt
    Using the seacen/meetcap repository and its agent skill, search my past meeting records for <topic or question> and report the meeting date, the agreed decision, and the transcript line it came from. Verify that the cited line actually contains the decision before you answer.

  • Put a firewall in front of your existing LLM calls

    Run AI-FW with Docker Compose and send your app's model calls through it for inspection and logging.

    View prompt
    In the securetron-gh/aifw repo, run `docker compose up -d` in <project-folder>, then send one chat completion request through the gateway to <model-name>. Report the HTTP status and the transaction ID shown in the dashboard, and verify the response is a valid chat completion.

  • Learn how a TTS model plugs into a serving framework

    Follow the learning articles and source links to see how Breeze TTS 2 runs inside vLLM-Omni.

    View prompt
    Using the repo Sentinel3252/Native-Breeze-TTS-2-Support-for-vLLM-Omni, read docs/learning-guide.md and docs/architecture.md, then write a 300-word summary of how a request moves from text input to audio output. Verify that every component you name appears in the README or those docs.

  • Compare a product's price in Toman across Iranian shops

    Ask an agent for the cheapest shop for a product, with prices in Toman, from Digikala and Torob.

    View prompt
    Using the awesome-iran-mcp servers digikala and torob, find the price in Toman of <product name> at every shop that lists it, then return the cheapest in-stock offer with its shop name and link. Check that every price in the answer comes from a tool result and is stated in Toman.

  • Make a riso film from a one-line prompt

    Describe a scene to Claude Code and get a single-file procedural riso film you can open and play in a browser.

    View prompt
    In the riso-windowseat repo, make a riso film of <scene description> using the riso-film skill in .claude/skills/. Expect a single index.html plus a FILM.md in films/. Verify the film plays in a browser and that its design notes are recorded in FILM.md.

  • Resume a Codex engineering task from where you left off

    Link past Codex sessions to a task so you can pick up the work with its context.

    View prompt
    Using the repository sevensir888/codex-command-center, outline how to link existing Codex sessions to the task named <task name> for the project at <project path>. Output a numbered list of the linking steps. Verify that the task shows the linked sessions and the project's branch before resuming.

  • Score a prose draft for AI-writing tells

    Run a local 0-100 score on a .docx, .md or other prose file before you publish it.

    View prompt
    Using the sloptrim repo at <repo path>, run `python scripts/detect.py <draft file>` on <draft file> and report the 0-100 score, the band and the named patterns. Verify that the output is valid JSON and includes a score between 0 and 100.

  • Rewrite an AI-drafted email offline before sending it

    Paste an AI-written email into a local app and get a version that reads like a person wrote it.

    View prompt
    Using the sgaofen/humanizer-local-model repo, install the app for this machine and rewrite the email draft at <path-to-draft.txt> with the app. Expected output: the rewritten email text. Verify that every number, date and name in the draft also appears unchanged in the rewrite.

  • Block arbitrary Tailwind values in agent-written UI

    Flag off-scale Tailwind values so agents use your theme's spacing, colors, and sizes instead.

    View prompt
    Use the GitHub repo shadcn-ui/lint to set up the no-arbitrary-values rule in <project-path>. Follow the README ESLint setup for React, then run the lint command. Expected output: a list of arbitrary Tailwind values in the project, or zero errors. Verify that the rule reports a test class such as p-[13px] in one component file.

  • Add an animated WebGPU background to a web page

    Drop a gradient with a cursor trail into a React, Vue, Svelte, or Solid page using the Shader component.

    View prompt
    In the shader-effects-inc/shaders repo, install the shaders package in <project-path> and add a Shader element with a LinearGradient and a CursorTrail as the page background for the framework used in <project-path>. Expected output: the edited component file and a short list of changed files. Verify that the import path matches the project's framework.

  • Send all app AI calls through one OpenAI-style endpoint

    Point existing OpenAI SDK code at one gateway that routes to several providers with failover.

    View prompt
    Using the ShadowSafin/Synapass repo, deploy the stack with ./scripts/deploy.sh, mint a tenant key, and send one chat completion to /v1/chat/completions for the model <model_name>. Report the synapass.provider and synapass.fallback_used values. Verify that the HTTP status is 200 and the response contains a choices array.

  • Serve a decision model behind a local API

    Run v6.1-VL 4B locally and get calibrated yes/no or pick-one answers over HTTP.

    View prompt
    In the Shanghua-Gao/RSI-Jev repo, install the package with pip, then run `rsi-jev serve v6.1-vl-4b --effort auto --port 8000`. Send the <question> about the text <input> to localhost:8000/v1/systemone and return the probability for each option. Verify that the response includes the layer that answered and a confidence value.

  • Test a mobile app flow on a real phone with an agent

    An agent opens your app, follows a test script, and reports what the screen shows.

    View prompt
    Using the phone-harness repo at https://github.com/ShawnPana/phone-harness, open <app name> on the connected phone, follow the test script <script path>, and report each step with the screen text it read. Verify that the last screen matches the expected result in the script before reporting success.

  • Try the adventure in a browser with no install

    Play the five-area browser demo with battles, catching, interiors, and local autosave.

    View prompt
    Open https://infinite-pokemon-blond.vercel.app/game/ for the Infinite Pokémon repo and play the browser demo for a short session. Report which of the five prepared areas you reached, whether one battle and one catch worked, and whether progress remained after a page reload.

  • Find support tickets by meaning, not keywords

    Count and group tickets that describe a problem, using a plain-language condition in SQL.

    View prompt
    Use the jev4pg repository to set up the workspace, import the CSV at <path-to-csv> as a dataset named tickets, and run a SQL query that counts rows where SEMANTIC(body, 'The ticket describes an unresolved billing problem.') is true, grouped by product. Return the grouped counts and confirm that the decision states and any uncertain rows are reported before the counts are treated as final.

  • Install Taskboard into a running DeepSeek Harness profile

    Add the Taskboard plugin to the web profile, verify it loads, and confirm the sidebar button works.

    View prompt
    Using the README at https://github.com/shengsheng90/DSH-taskboard, install @shengsheng/dsh-taskboard into the web profile of the DeepSeek Harness running from <harness-checkout-path>. Run `dsh --profile web --dump-config` and confirm it ends with a `# == @shengsheng/dsh-taskboard` layer. Report the count of `@shengsheng/dsh-taskboard` in `GET /` and the HTTP status of the client.js bundle, and do not restart Harness without telling the operator first.

  • Turn your illustration into an animated 2D avatar

    An agent builds a mesh avatar from your PNG, and you check it in the local editor.

    View prompt
    In the mesh-avatar-studio repository, follow docs/agent-guide.md to create an avatar from <path to your PNG>. Expect a project folder under projects/ that the editor can open. Verify by confirming that Pose test and Lip sync run in the preview.

  • Triage a source tree for reachable, unauthenticated sinks

    Let an agent scan your code and report sinks that are reachable without auth, with file and line references.

    View prompt
    Using the blitzstrike MCP server, call run_engagement with target <path to source tree> and max_files <number>. Return the findings grouped by chain, each with file and line references. Verify that every finding names a source and a sink that the tool traced, not only a matched pattern.

  • Design a printable hose adapter from a text description

    Describe a part in plain words, let the AI model it, and export a 3MF ready for your slicer.

    View prompt
    Using the nurb repo (Shpigford/nurb), install it and build a part for <target part description>. Expected output: a live viewer showing the part and a 3MF export. Verify by running `nurb check` and confirming it reports the findings for that part.

  • Run a private personal AI agent from a source checkout

    Build the console, start the gateway, and chat with a self-hosted agent on your own machine.

    View prompt
    Work in the Sidiora-Labs/centra-gideon-agent checkout and set up a self-hosted instance using the README self-host steps with GIDEON_HOME set to <state-directory>. Report the console address the gateway prints and the result of the gideon setup prompts. Verify that the gateway answers HTTP requests on port 10000 before reporting success.

  • Turn a feature idea into a verified task plan

    Create a spec, lint it, and mark tasks done only after the graph and history agree.

    View prompt
    In the Hyperfide repository at <repo path>, create a spec for <feature name> using `hyperfide spec new` and `hyperfide spec add`, then run `hyperfide spec lint`. Report the task list with dependency waves and any lint errors. Verify that every task lists the paths it touches.

  • Build the LayerX kernel and run its test gate

    Compile the C17 LayerX kernel and run the local test and CI targets before any change.

    View prompt
    Clone Sidiora-Labs/Paxeer-X-Network and run make build, make test and make ci from the repo root. Report which targets passed or failed and the first error from any failure. Verify that no deployment or custody step was run.

  • Install an ad-free home screen on Google TV with Claude Code

    Let Claude Code build Free My TV and install it on a Google TV or Android TV in about ten minutes.

    View prompt
    In the free-my-tv repo, install Free My TV on the TV at <TV_IP> for the city <CITY>, following the Install section of README.md. Expected output: the app is built as FreeMyTV.apk and installed on the TV with adb. Verify by checking that the TV's Home Screen setting offers Free My TV after the install.

  • Validate the 60-task benchmark catalog locally

    Check the public task catalog and protocol config before building on the benchmark.

    View prompt
    In the Simreal-MLBench repository, create a virtual environment, install the package with `python -m pip install -e '.[test]'`, and run `mleb validate configs/catalog.json`. Report whether validation passed and how many tasks the catalog lists. Confirm the count is 60 before reporting success.

  • Point Claude Code at your own OpenAI-compatible gateway

    Write the gateway URL, key, and model into Claude Code settings without losing existing config.

    View prompt
    Work in the cloned repo Sinholms/setup-gateway. Run `node bin/setup-gateway.mjs claude --base-url <GATEWAY_BASE_URL> --api-key <API_KEY> --model <MODEL_ID> --yes` and report the written file path. Then run `node setup-gateway.mjs status` and verify the printed base URL and model match the values passed in.

  • Make an explainer video from one sentence

    Type a topic, approve the storyboard, and get a 1080p narrated MP4 with subtitles.

    View prompt
    Use the Frametell repo at sitor-ai/frametell. Build it with pnpm install and pnpm build, then start the studio with node apps/cli/dist/cli.js serve and create a video about <topic> in English. Expected output: a 1080p MP4 with subtitles; verify that the storyboard was shown for approval before any pages were drawn.

  • Install a Codex pet from two or more photos

    Turn your own photos into an installed Codex companion pet with one create command.

    View prompt
    Using the repo six-nut/PocketMen-with-you, run `pocketmen doctor`, then create a companion with `pocketmen create` from the two reference images at <photo-1> and <photo-2>, output to ./pocketmen-output with --install. Expected output: pet.json and spritesheet.webp in the output folder and an installed Codex pet. Verify the atlas is 1536x1872 with 8 columns and 9 rows.

  • Build a source-backed knowledge base from your documents

    Set up a separate Markdown workspace and file documents with the Codex backend after review.

    View prompt
    In the knowledge-base-kit repo, initialize a Codex workspace at <workspace-path>. Then open that workspace in Codex and use the local process_docs skill with the Codex backend on <document-path>, and show the proposed category and changed files before filing. Verify that the workspace passes `python kb.py check --backend codex`.

  • Get a cold second review from the other vendor's agent

    Have a fresh agent from the other vendor check your change before it lands.

    View prompt
    In the repo <repo-path>, use the peer-review skill from Sno Station Skills on the latest uncommitted change, preferring the other vendor's CLI in a fresh session. Output the findings list with each finding's trigger, impact and refutation attempt. Verify that the first line of the report states whether the review was same-vendor.

  • Hand off a half-finished task when one agent hits its limit

    Another agent picks up the same task from shared memory with context intact.

    View prompt
    In the sno-station repository, use `sno reach call` to hand the current task from the agent at <placeholder> to the other agent. Expected output: the receiving agent restates the task and the last completed step from shared memory. Verify it does not restart the task from the beginning.

  • Build a source-cited social research report

    Run a read-only research goal across Instagram, TikTok, or LinkedIn and get a cited Markdown report.

    View prompt
    Use the socai-io/jev-social repo to research <topic> on <platform> in my signed-in Chrome. Expected output: a source-cited report.md. Verify that every finding links to a captured source URL and that any login gate is reported as a partial result, not a success.

  • Watch coding agents work live in a 3D kitchen

    Run Agenttrail Kitchen in your repo to see agent tasks, roles and completed work update as you code.

    View prompt
    In the repo <repo-path>, run `npx agenttrail-kitchen .` and confirm the browser opens at localhost:4780 or the next free port. Report the URL that is shown. Verify that the terminal stays running and that the view is in Live mode, not Example mode.

  • Stop an AI coding agent from reading your .env secrets

    Install the local guard so an agent is refused when it reaches for a .env file and every decision is logged.

    View prompt
    Install the SolonGate guard from https://github.com/solongate/agent-security by running ./scripts/shell/install.sh in a fresh terminal, then start <agent> in <project-path> and ask it to read the .env file. Expected output: the guard refuses the read and the agent reports the refusal. Verify by running `solongate audit` and confirming a deny entry for .env exists in ~/.solongate/local-logs/solongate-audit.jsonl.

  • Run Maid Kit locally to manage servers over SSH

    Build and launch the desktop app to view server status, open terminals, and edit files over SSH.

    View prompt
    In the Solsynth/MaidKit repo, run `flutter pub get` and `flutter run` to start the desktop app, then add the server at <server-address> with the SSH login <ssh-user>. Expected output: the server card appears on the Dashboard with live status and load. Verify that the Terminal tab opens a shell on <server-address>.

  • Find a reverse-engineering case for an old device

    Match a legacy printer, scanner, or appliance to a documented case and check its evidence status.

    View prompt
    Use the GitHub repo songshikang0111/awesome-REA-cases to find cases for <device model>. Return up to five matching case titles with links, each marked with its status and whether its evidence was independently reproduced. Verify that each status comes from the case page, not from the README summary.

  • Control lights, OBS and PC apps by voice on Windows

    Install Jarvis on a Windows 11 PC and use the wake word to run lights, OBS and app commands.

    View prompt
    In the sosoj92/jarvis-assistant-vocal repo on Windows 11, set up Jarvis and configure the <lights or OBS> tool for <target scene or light name>. Expected output: the assistant responds to a spoken command and the target changes state. Verify the change in the Hue app or OBS before reporting success.

  • Start a Next.js project from a product idea

    Turn a short product description into a configured Next.js foundation with product docs and checks.

    View prompt
    Read the repo soumatheusgomes/vibe-coding-toolkit at docs/prompts/11-next-project-bootstrap.md and execute the setup in this directory for the product described as <product description>. Report the generated files, the checks that passed, and the next MVP task. Verify that PRODUCT.md exists and that the validation step ran.

  • Run a background research agent with a cited summary

    Set up Xiryn once, then have an agent research a topic in its own desktop while you keep working.

    View prompt
    Using the open-source repo SouravBeraAkaSpeed/xiryn, set up Xiryn on this computer and ask its research agent to produce a cited summary on <topic>. Expected output: a summary with a list of cited sources. Verify that every claim in the summary links to one of the listed sources.

  • Fix a bug and add a regression test with Claude Code

    Send a bug fix goal to Claude Code through Autoprompt and get a fix plus a regression test.

    View prompt
    Using the Spielewoy/autoprompt-skill repo, run `autoprompt activate claude --target <absolute project path> -- "fix the registration race and add a regression test"`. Expected output: a code change for the bug and a new regression test. Verify that the project's test command runs and the regression test passes.

  • Turn a locked-camera video into a Mixamo animation

    Retarget a single-performer video onto your Mixamo rig as a headless FK clip in Blender.

    View prompt
    In the squall01337/mixamo-llm-mocap repo, take the video at <video path> and an action spec for it, then run the SMPL-X path (estimate_pose_gvhmr.py --smplx-only, retarget_smplx.py, bl_motion.py -b apply) onto the rig <rig .blend path>. Expected output: a saved .blend with the action keyed on the Mixamo rig. Verify the .blend exists and the action name in the spec matches the action in the file.

  • Ask cited questions across your own PDF library

    Run Thesys locally, upload papers, and get chat answers that jump to the exact passage in each PDF.

    View prompt
    Use the Sreehari05055/thesys-core repo to set up a local research workspace with Docker, set OPENAI_API_KEY and EMAIL in backend/.env, and upload the PDFs in <path-to-pdf-folder>. Report the chat answer to the question <your question> and the citation it links to. Verify that clicking the citation opens the highlighted passage in the PDF preview.

  • Approve Claude Code permission prompts from the desktop

    Answer Claude Code allow or deny prompts from a desktop card instead of returning to the terminal.

    View prompt
    In the clawd-conduit repo, run `bash install.sh` for a Claude Code setup on this Mac, then confirm port 23333 is listening with `lsof -nP -iTCP:23333 -sTCP:LISTEN`. Report the output and whether a permission card appears in a new session that requests a permission.

  • Build and run the Starling desktop from source

    Compile the Swift shell and run the Starling desktop from a staged tree on Linux.

    View prompt
    Clone the starling repo and its starling-engine sibling, then run ./bootstrap.sh and build/run-desktop.sh on this Linux machine. Expected output: the Starling desktop session starts from the .stage/ tree. Verify that the .stage/ directory exists and that the desktop process is running before reporting success.

  • Route support tickets to teams with typed decision questions

    Run a local decision server and get a team, urgency and severity answer for each ticket.

    View prompt
    Using the StartLux-Decision repo, start the decision server with the 4B AutoThink model and send the ticket text <ticket_text> to POST /v1/systemone with a choice question named team, a noul question named urgent and a score question named severity. Return the answers JSON. Verify that the team answer is one of the listed criteria keys.

  • Watch every coding agent from one screen

    See each agent's status across all tabs and answer permission prompts without switching windows.

    View prompt
    Using the Tellurion repo at https://github.com/steventsvik/Tellurion, set up live status for Claude Code and Codex, then open Mission Control (⌃⌘M) with two agents running in <project-folder-1> and <project-folder-2>. Report the status shown on each card. Verify that a waiting agent appears first in the list.

  • Summarize a web page inside your AI chat

    Send a page or selection to Copilot and get a structured summary in the same AI chat.

    View prompt
    Using the Superpower repo at https://github.com/stloendays/Superpower, set up the browser extension with a Streamable HTTP connection to http://localhost:3006/mcp, then summarize the selected text on <target page URL> in the Copilot workspace. Expected output: a structured summary in the AI chat. Verify that the summary cites points that appear on the source page.

  • Run a coding agent inside a restricted Box sandbox

    Start an agent in a Box sandbox whose file, program, and network access you set in config.

    View prompt
    Using the strands-agents/box repository, download the binaries with its download.sh script, then write a box.toml that gives <agent-name> read access only to <project-folder>. Expected output: `./box-core/box --version` prints a version string and the box starts with the configured grants reported at startup. Verify that the agent cannot read a file outside <project-folder>.

  • Route support messages to the right team

    Pick the owning team for an incoming message, with a confidence score on the choice.

    View prompt
    Using the strands-decider repo, run the ask command with --state set to <message text> and a --choice question listing the team names <teams>. Return the chosen team and its confidence. Verify that the confidence is a number between 0 and 1 and that the chosen team is one of the listed options.

  • Render a 15-second beat-synced reel from one line

    Turn a one-line theme into a 60 FPS HyperFrames MP4 locked to a 120 BPM grid.

    View prompt
    In the hyperframes-motion-reel-skill repo, run /hyperframes-motion-reel with the theme <one-line theme> and a duration of <seconds>. Expected output: a delivery-quality MP4 at 60 FPS in the generated project. Verify that npx hyperframes check reports 0 findings before rendering.

  • Run Qwen3.5-9B on a 24 GB GPU with long context

    Fit Qwen3.5-9B on an RTX 4090 and chat in the terminal with more KV cache room.

    View prompt
    Using the repo surya-koritala/Glyd on a Linux machine with <GPU model> and driver <driver version>, install Glyd with its install script from getglyd.com and run `glyd run Qwen/Qwen3.5-9B`. Report the context length Glyd sets up and the GPU settings it applies. Verify that the terminal chat opens and returns a reply to a test question.

  • Get daily alerts when shortlisted companies post a match

    Set a shortlist of companies and receive email plus desktop alerts when a scored opening clears your threshold.

    View prompt
    In the jobradar repo, set up the project, put <resume.pdf> in place as the resume, and set alerts.companies in config.yaml to <company list>. Run ./run.sh test and confirm a test email is sent, then report the result. Verify that the test email arrives in the inbox before reporting success.

  • Get an SMS verification code for an agent signup

    Let an agent order a number, read the SMS code and close the activation in one run.

    View prompt
    Using the sv-number/mcp-server MCP tools, order a number for service <service code> in country <country id>, then call wait_for_code on its activationId. Expected output: the verification code as returned by wait_for_code, followed by a finish_activation result. Verify that the code is parsed text and not a raw SMS body before you use it.

  • Plan a New York outing with Claude in minutes

    Add SyncSo as a Claude connector and ask for live New York events with prices and booking links.

    View prompt
    Using the SyncSo MCP server at https://rtdb.syncso.com/partner/mcp (repo SyncSo-Inc/syncso), find free outdoor events in New York starting in the next four hours. Return a list with the name, time, price, and booking link for each. Verify that every item has a booking link and that the location is in New York.

  • Stop local AI engines from crashing each other on one GPU

    Queue llama.cpp, ComfyUI and other engines on one card so none load into an out-of-memory crash.

    View prompt
    In the Berth repo at <path to berth>, install the berth binary and run `berth service install --harbor`, then start <engine command> with `berth run --as <name> -- <engine command>`. Expected output: `berth status` lists the engine as the card holder. Verify that a second engine started through `berth run` shows as waiting with a reason, not as a crash.

  • Run Tab Tin from source on your own machine

    Clone the repo and start the quick or full local preview with a coding agent or by hand.

    View prompt
    Run the quick preview of the TabTin repo at <local-clone-path> by following docs/development/community-dev-agent-prompt.md. Report whether the backend health check passed and whether the Electron window is ready, and confirm that the root .env file is not staged for commit.

  • Solve a ready-made bracket analysis in minutes

    Open a bundled sample, press Solve and read the von Mises stress on a hex-meshed bracket.

    View prompt
    Using the FieldCraft repo at tangency-labs/fieldcraft, run the sample named bracket-hex with `fieldcraft --sample bracket-hex`, solve it, and report the peak von Mises stress and the reference check described in docs/examples.md. Verify that the solve finished without errors before reporting the value.

  • Transcribe live-stream speech and separate speakers

    Turn a live-commerce audio track into a transcript that labels who said what, using TLive Omni's ASR features.

    View prompt
    Using the TLive-Omni repo at https://github.com/TaoLiveAIGC/TLive-Omni and its model card on Hugging Face, produce a speaker-attributed transcript of <path to live-stream audio>, with timestamps where the model provides them. Verify that speaker labels stay consistent across the first five minutes of the transcript before reporting the result.

  • Point an OpenAI SDK app at one free-tier endpoint

    Route any OpenAI client library across many free providers through a single local /v1 URL.

    View prompt
    In the freellmapi repo (tashfeenahmed/freellmapi), start the router locally and set the OpenAI SDK base URL in <project-path> to http://localhost:3001/v1 with the unified key from the Keys page. Expected output: a successful chat completion from the app. Verify that the response includes a model name and that the router dashboard shows one request logged.

  • Build a personal workbench for a recurring project

    Describe a long-term goal and let the native AI set up a project workspace you keep using.

    View prompt
    Using the WorkDSH repo at techflag/workdsh, describe the goal <your goal> to the native AI and have it build a project workbench. Expected output: a project with instructions, tasks and checklist for that goal. Verify that the project appears in the sidebar and reopens after restarting the app.

  • Build and install an Android app entirely on your phone

    Write, build, and install a debug APK on Android with no PC and no USB debugging.

    View prompt
    In the Mobile Harness app on an ARM64 Android phone, create a new project, ask the AI Workspace to build a simple Android app, and tap the play button. Expected output: a debug APK installed and launched on the phone. Verify that the install prompt appeared and the app opens.

  • Make a launch film from a brand website

    Capture a brand from its site, pick one idea it could own, and render a checked motion film in plain HTML.

    View prompt
    Use the motionmaxxing skill from Tejashmakwana/motionmaxxing to make a launch film for <brand website URL>. Show me the idea and storyboard before building, then render final.mp4 and NOTE.md. Verify that the gate results in NOTE.md match the script output.

  • Generate speech in a reference speaker's voice

    Turn a script into spoken audio that keeps the voice of a short reference recording using zero-shot TTS.

    View prompt
    Using the Tencent-Hunyuan/AuK repo, set up the environment and download the AuK and Qwen2.5-Omni-3B weights, then run auk-infer with <reference.wav> and the target text <target text> to write <out.wav>. Verify that <out.wav> exists and plays back at about the requested length, and report the path only if the speaker permission for <reference.wav> is confirmed.

  • Run a production agent with swappable model providers

    Build one deepagents-based agent that can switch between OpenAI, Anthropic, Bedrock, and preset providers.

    View prompt
    In the TencentCloud/octop-harness repo, create a HarnessAgentManager with one agent that uses the model provider <provider>. Send the prompt <prompt> through call() and return the reply. Verify the reply is non-empty and that exceptions from call() are caught.

  • Build a playable 2D web game from one prompt

    Install Vibe Game, describe a game in plain language, and get a playable 2D browser game.

    View prompt
    Using the VibeGame repo at https://github.com/tettethu/VibeGame, set it up with ./setup.sh, create a project in my-game with vibegame init, and start it with vibegame start using the prompt "<game idea>". The expected output is a playable 2D web game in my-game, launched with vibegame run --port auto. Verify that the run command prints a local address and the game loads in a browser.

  • Carry Claude Code project context into new sessions

    Install the Claude Code plugin so earlier session context appears automatically when you start a new session.

    View prompt
    Install the claude-mem plugin in Claude Code for the repo at <project path> using `/plugin marketplace add thedotmack/claude-mem` and `/plugin install claude-mem`, then restart Claude Code. Report whether a new session in <project path> shows context from a previous session. Verify by checking that the injected context references work from the earlier session.

  • Build an AI IT department with Paperclip

    Install Paperclip, hire a CEO agent, and bring in specialist agents for IT work.

    View prompt
    Using the repo theNetworkChuck/paperclip-guide, follow chapters 2 through 5 to set up a Paperclip company on <target machine>. Report the list of hired agents with their harness and manager. Verify that every hire shows an approval by the board before it became active.

  • Self-host a photo editor for your home network

    Serve your photo folder from one computer and edit it in any browser on your network.

    View prompt
    Using the repo thesnarkitecht/rembrandt, run the self-host install on <target-computer> with the --server option and report the private link it prints. Verify that the photo folder you chose still contains only its original photos and that any edit creates an XMP file beside the photo.

  • Run a chat app that answers trip questions with maps and itineraries

    Run the demo locally and get a map, photos and an editable plan back for a travel request.

    View prompt
    Clone thesysdev/open-intelligent-ui, follow its Setup section, and start the dev server. Send the prompt "I'm in San Francisco for a day, plan a sightseeing route for me" to http://localhost:3000 and report whether the answer includes a Map component. Then list the component names used in src/lib/library.ts that the answer relies on.

  • Scaffold a streaming generative UI chat app

    Create a ready-to-run app that streams OpenUI Lang output and renders it as live UI.

    View prompt
    Using the thesysdev/openui repo, scaffold a new app named genui-chat-app in <target folder> by running `npx @openuidev/cli@latest create --name genui-chat-app`. Report the start command the CLI prints and confirm that a test prompt in the running app produces streamed UI rather than plain text.

  • Route support tickets to a queue in one call

    Send each ticket to one of five queues with a System 1 model and a probability.

    View prompt
    In the system1-agents repo, route each ticket in <ticket-file> to one of logistics, payment, returns, account or human using `s1a decide`. Return one JSON line per ticket with the chosen queue and its probability. Verify that every output has a choice that matches one of the five queue names.

  • Ask the car about a warning light with no internet

    Ask the car by voice what a warning light means; it answers from its own owner's manual.

    View prompt
    Using the CarWatch repo at https://github.com/ThinkOffApp/CarWatch on <pi-host>, send the room agent the question 'What does the yellow tyre light mean?' and return the answer text with its page citation. Verify that the answer cites a manual page and that the test ran with no internet connection.

  • Connect Claude Code once, then switch upstreams in the gateway

    Point Claude Code or Codex at a local gateway once, then change providers without editing the client again.

    View prompt
    Using the repo ThinkWatchProject/ThinkWatch-Lite, connect <client name, e.g. Claude Code> to the local gateway, add the upstream <upstream name> in the gateway, and switch to it without editing the client's configuration again. Expected output: a test request from the client that completes through the new upstream. Verify that the client's original config file exists as a backup.

  • Check an AI-assisted paper before you sign it

    Run paper-author-pass to get questions only you can answer, a claim-evidence map, and verified references.

    View prompt
    Use the absent-author repo's paper-author-pass skill on <paper folder> in audit mode. Ask me the questions only the author can answer, then produce a claim-evidence map and a change log. Verify that every reference the skill marks as verified can be found by you in the bibliography.

  • Draft a task-specific harness in Claude Code

    Install the Jev Harness plugin and have Claude Code draft a Jev decision harness for your task.

    View prompt
    Using the JevHarness repo at https://github.com/TianyuCodings/JevHarness, invoke the jev-harness skill to draft a harness that routes <ticket type> to the right team. Ask for inputs, legal actions, examples, success criteria, and budget before writing any code. Expected output: a plan listing those items. Verify that every legal team action appears in the plan.

  • Share one memory of decisions across Claude Code and Codex

    Let Claude Code and Codex read and write the same store so past decisions carry into new sessions.

    View prompt
    Use the agent-memory repo at <store path> to recall memories about <topic> with `mem recall` and `mem context`. Return the file paths and one-line abstracts that matched. Verify that the same paths come back when the query is run from Claude Code and from Codex.

  • Check a live site's SEO foundation in one run

    Give the agent a URL and get a crawler's-eye pass/fail report on 26 structural SEO checks.

    View prompt
    Using the tigerless-labs/seo-ops skill, check the SEO foundation of <target-url> as a live site. Return the pass/fail report for the 26 checks with evidence for each red item. Verify that the report lists every check as pass or fail and does not guess at checks it could not run.

  • Host a private daily planner you own

    Run Mojito on your own server to get Today, plans, notes, feed and chat in one place.

    View prompt
    Using the TimeLovercc/mojito repo, follow docs/SETUP.md to deploy the hub on <target-server>. Report which steps succeeded and the URL of the running web app. Verify that the Today page loads and that the chat responds.

  • Serve NeoHorse-1 locally for agent tool calls

    Host NeoHorse-1-4B on your own GPU with vLLM and send it chat requests from a local script.

    View prompt
    In the TokenRhythm/NeoHorse repo, follow the vLLM steps in the Deployment section to serve the NeoHorse-1-4B checkpoint at <model-directory> on port 8000 with served name neohorse-1-4B. Return the chat reply text for the prompt <test-prompt>. Verify that the server log shows the model loaded without errors before sending the request.

  • Investigate a bug and review a proposed fix

    Have Eido's agent explain a bug, propose a small fix, and suggest a check before you accept it.

    View prompt
    Using the Eido repo (tony3liu/eido) as the workspace, open the project at <project-folder> and ask the agent to explain the bug described in <bug-report> and propose a small fix with a way to check it. Expected output: a written cause, proposed file changes shown in the review interface, and a check the agent recommends. Verify that no change is accepted until it has been reviewed in the review interface.

  • Run a planner, engineer, and reviewer team on a small task

    Import the example recipe and have three team members build and test a small app in a scratch project.

    View prompt
    Using the dsh-agent-team-gui repo, import examples/full-stack-delivery.recipe.json into an empty scratch project at <project-path> and run the to-do list task from docs/first-team.md. Report the Team runs summary with the plan, member outcomes, and Token coverage. Verify that the built project's test command passes before reporting success.

  • Dictate text into any Mac app by holding fn

    Install Talkify and dictate on-device by holding fn, speaking, and releasing.

    View prompt
    In the repo tornikegomareli/Talkify, confirm that the README says recognition runs on-device with Apple's SpeechTranscriber. Report the one-line install command and the fn gesture that starts dictation. Verify that the README states Talkify makes no network requests.

  • Let ChatGPT edit and test a local project

    Give ChatGPT approved folder access so it reads files, edits code and runs tests with real tool results.

    View prompt
    Using the repo totec448-spec/chat-on-steroids, connect ChatGPT to the project folder <project-path> with read and edit access. Ask ChatGPT to fix the failing test named <test-name> and run the test suite. Expected output: a list of changed files and the test command results. Verify that the test results shown come from the local run, not from ChatGPT's own description.

  • Feel Claude Code turn events through a vibration device

    Install the plugin, pick a device in Intiface Central, and feel Claude Code's activity as it runs.

    View prompt
    Install the plugin from the transkatgirl/vibeclaude repo into ~/.claude/vibeclaude, run npm install there, and load it with claude --plugin-dir. Report the output of /intiface-intensity with no argument and confirm that the selected device is <device name> in the /intiface list. Verify that the daemon answers after running node daemon/daemon.mjs status.

  • Build a working ML framework from raw NumPy modules

    Work through 20 CLI modules that rebuild tensors, autograd, optimizers, and transformers.

    View prompt
    Clone https://github.com/TrenTorch/TrenTorch, enter TrenTorch_CLI, create a virtualenv, install requirements and the package, run `tren setup`, then `tren module start 01`. Report the path of the generated notebook under data/modules and confirm that the stub file exists without any import of torch.

  • Run a local agent chat with your own models and tools

    Start TrueForge on one machine and chat with an agent that uses MCP tools and skills.

    View prompt
    Using the truefoundry/trueforge repo, start TrueForge locally with `npx @truefoundry/trueforge@latest`, connect the model <model-provider>, and create an agent that uses one MCP server named <mcp-server>. Report the agent's name and the URL of the chat UI. Verify that the agent answers a test prompt and that the session appears in Sessions.

  • Give an agent its own email inbox and webhook feed

    Run Sentio locally, confirm it is healthy, and follow the walkthrough to give one agent a real inbox.

    View prompt
    Clone the truespar/sentio repo, start it with docker compose up -d, and confirm localhost:8080/health/ready returns status ok. Then give the agent named <agent-name> its own inbox by following the README section 'Give an agent its own inbox', and report the mailbox address created. Verify that the webhook endpoint for <agent-name> is set before reporting success.

  • Run the CRM locally with a sample pipeline

    Clone the repo, start Postgres in Docker, and open a seeded CRM on your own machine.

    View prompt
    Clone the trycompai/crm repo, copy .env.example to .env, set BETTER_AUTH_SECRET and ALLOWED_SIGN_IN, then run bun install, docker compose up -d, bun run db:deploy, bun run db:seed and bun run dev. Report the URL that serves the app. Verify that http://localhost:3001 responds before you finish.

  • Review AI-written changes and run a repair plan in an agent

    Mark up uncommitted AI changes in Reslop, save the review as a plan, then let a local agent work through it.

    View prompt
    In the reslop repository at <repo-path>, read the newest file in .plan/ with status editing and work through its unchecked items. Report which checkboxes you marked [x] and which items remain. Verify by confirming the frontmatter status is set to partial or done and no unchecked items were skipped silently.

  • Audit a whole repo for safe simplification candidates

    Get a ranked list of simplification candidates with proof records, counterexamples and blind spots, with no file changes.

    View prompt
    Use $simplify-codebase on the repository at <path to repo>. Run a broad read-only Survey and do not modify any files. Expected output: ranked proof records with coverage, counterexamples, open questions and the next evidence needed. Verify that every candidate names its consumers and its deletion boundary.

  • Give Codex a durable, size-capped memory of your repo

    Install the memory pack so Codex keeps a one-page project card and handoff per repo.

    View prompt
    In the ai-memory-skillpack repo, follow INSTALL.md to install the ai-project-memory skill for Codex on this machine, then enable the repo at <repo-path>. Report the install receipt location and the list of files created under docs/ai/ in <repo-path>. Verify that sha256sum -c SHA256SUMS passed before any install step ran.

  • Catch repeated effects in a promo storyboard

    Run the variety audit on a storyboard to flag repeated transitions, entrances and eases before you build.

    View prompt
    Use the saas-motion-kit repo. Fill templates/STORYBOARD.md for <product name> with a Message & tone sentence and one ledger row per shot, then run `python tools/variety_audit.py STORYBOARD.md`. Expected output: the audit report of repeats. Verify that the report is empty or that each repeat is marked as a motif before you hand the storyboard on.

  • Extract typed fields from receipts into structured data

    Turn receipt text or images into merchant, total, expense type and reimbursable flags as typed values.

    View prompt
    Use the Python package typellm in the repo TypeLLM/TypeLLM to extract merchant, total, expense_type and reimbursable from the receipt text at <receipt_path>. Call TypeLLMClient.generate() with an enum for expense_type and return response.result as JSON. Verify that expense_type is one of the enum values and total is a number.

  • Stop coding agents from re-watching the same footage

    Install the CDAF skill and generate sidecars so Claude Code reads text instead of video.

    View prompt
    Using the CDAF skill in the repo UditAkhourii/cdaf, check <footage-folder> for a .cdaf sidecar next to each video, verify the bytes and sha256 header against the video, and read the sidecar instead of watching any fresh video. Report the list of videos with their status (FRESH, STALE, or MISSING) and confirm that you did not run a video analysis on any FRESH file.

  • Check arXiv prior art before designing a new architecture

    Have Claude Code pull real arXiv papers and return one cited design path before any code is written.

    View prompt
    Using the NeuroArxiv skill in the UditAkhourii/neuroarxiv repo, run /neuroarxiv on the problem "<your design problem>" before designing anything. Return the single recommended approach, its arXiv citations, the first step, and the pitfalls listed for every paper. Verify that each cited arXiv id resolves before you rely on it.

  • Shortlist the files that handle a concern before Claude reads them

    Ask Jev which files in a big repo match a condition, then give Claude only those paths.

    View prompt
    Using the repo UditAkhourii/quicksilver, run qs filter with a yes/no question about <concern> against <target-directory>. Return the matching file paths and list any borderline items marked with ?. Verify that the output ends with a receipt line showing files scanned and the Jev cost.

  • Let Codex or Claude Code edit an Unreal project via MCP

    Connect an external coding agent to a running Unreal Editor so it can call engine tools.

    View prompt
    Using the UE Box MCP server in the ueboxai/uebox repo, count the light actors in the level <level name> and report the count. Then list the tool calls used and confirm the editor project is still open with no unexpected changes.

  • Run a shared team agent server on one machine

    Install UFO on SQLite and local files so a small team can chat with agents on its own hardware.

    View prompt
    In the ufo-core repo, follow the Quick start to run `make install`, `make build`, `make init EMAIL=<work email>`, and `make serve`. Expected output: the server listens on http://localhost:8710 and `~/.ufoctl/token` exists. Verify that `curl http://localhost:8710` returns a response before you report success.

  • Keep CI and dependency PRs green while you work

    A repo-keeper agent watches CI and dependency PRs, fixes what breaks, and asks before anything ships.

    View prompt
    Using the Overtime repo at ukanwat/overtime, set up an agent named repo-keeper briefed to watch CI and dependency PRs for <target repo>. Expected output: a short list of failing checks and open dependency PRs, with a fix or a question for each. Verify that no merge happens without an approval question being answered.

  • Turn saved articles into a self-linking wiki

    Copy the starter vault, clip an article, and let the agent file it into linked wiki pages.

    View prompt
    Using the second-brain-os repo, copy vault-template to ~/brain and copy skills, commands, agents and scripts into ~/brain/.claude and ~/brain/scripts. Place one article in ~/brain/raw/, run /ingest, and report the wiki pages created. Verify that every new page has at least one wikilink to another page.

  • Run async agent tasks on the cloud runner

    Submit tasks to the cloud agent runner with unique input IDs so redelivered work is not repeated.

    View prompt
    Using the unreal-agent repo at <repo path>, build cmd/unreal-agent-runner and submit the task <task description> as one input with the unique ID <input id>. Expected output: a session history entry for that input and its result. Verify that sending the same input ID again does not run the task twice within the same session.

  • Open projects from a home machine on your laptop

    Run a headless Rune node on a dev machine and open its mounted projects from any other Rune instance.

    View prompt
    Using the repo unstablebuild/rune, follow the headless section of its README to start a headless node with --hostname devpod and the projects folder mounted, then run `docker logs -f rune` and report the sign-in code location. Confirm the node is running with `docker ps` before reporting success.

  • Hand off a code fix and get a pull request back

    Send a bug or feature request from the web app and receive a pull request from an isolated agent workspace.

    View prompt
    Using the UseAgent hosted app, start a thread that asks the agent to fix <bug description> in the GitHub repository <owner/repo>, then open the pull request it creates. Expected output: a pull request URL for the change. Verify that the pull request diff touches only the files related to <bug description>.

  • Run a rigorous coding task through the p3 mode router

    Install the skills, map models once, then let p3-mode pick a playbook for a request.

    View prompt
    In the repo at <repo-path>, use the p3-stack skills: run /setup-p3, then run /p3-mode on the task <task description>. Expected output: the code change plus the playbook steps taken. Verify that p3-models.md exists and lists a provider and model for each role.

  • Run DSH sessions on a ChatGPT subscription

    Log in to Codex once in the DSH web UI and pick its live models in any session without an API key.

    View prompt
    Using the dsh-plugin-subscriptions repo, log in to the ChatGPT (Codex) subscription in DSH Settings, Subscriptions, then start a session with the Codex model <model-name>. Expected output: a normal chat reply from that model. Verify that the Codex card shows as logged in and the model appears in the session picker.

  • Give a coding agent the Jev list as a skill

    Install the Awesome Jev list so an agent can look up Jev tools and docs on its own.

    View prompt
    Install the skill from the repo valentynkit/awesome-jev-typesafe, then fetch https://awesomejev.vercel.app/projects.json once and list the entries that match <task>. Expected output: a short list of project names with one-line descriptions and URLs. Verify that every URL appears in projects.json.

  • Run Claude Code on a local model with no cloud calls

    Point Claude Code at Qwen3.6-35B-A3B on your own PC to edit and test code privately.

    View prompt
    Use the PolyStrata repo at <repo path> with Qwen3.6-35B-A3B served on localhost. Ask Claude Code to add a --json option to <target script>, write a test for it, and run the tests. Expected output: the code change, the new test, and the test run result. Verify that the test run passes and that no request went to a remote host.

  • Find the page that answers a question in a long PDF

    Searches a 300-page report by tree, then returns the pages that answer your question.

    View prompt
    Using the repo VectifyAI/jev-doc-search, run tree_search.py on <path-to-pdf> with the question <question>. Report the sections and pages it kept and the doc_id. Verify by opening the first kept page of the PDF and confirming the figure or claim appears there.

  • Caption a video locally with WhisperX at no cost

    Transcribe a video offline with WhisperX and get a transcript.json for captioning.

    View prompt
    In the Open Edit repo at veedstudio/open-edit, use the @veedstudio/openedit-cli commands to transcribe <video path> locally with the whisperx provider. Expect a transcript.json under runs/ for that video. Verify that the file contains word-level timestamps before you continue.

  • Turn a labeled GitHub issue into a reviewed draft PR

    Label an issue factory and get a reviewed draft pull request to review and merge.

    View prompt
    Work on the GitHub repository <owner/repo> using the factory label on issue <issue-number>. Confirm the factory opens a draft pull request linked to the issue, and check that the draft PR's CI runs and reports a result before anyone marks it ready.

  • Draft launch announcement posts for every social channel

    Ask the team lead for launch posts and get X, LinkedIn, and Bluesky drafts waiting in Typefully.

    View prompt
    Using the marketing team template in vercel-labs/marketing-team-eve-template, ask the lead agent to draft launch announcement posts for <product launch>. Expected output: an X thread, a LinkedIn post, and a Bluesky post in the Typefully queue, unscheduled. Verify that no post is scheduled until a human approves it.

  • Install a skill into a project for Claude Code

    Add a published agent skill to one project so Claude Code can follow its instructions.

    View prompt
    Using the vercel-labs/skills CLI, install the <skill name> skill from <source repo> into this project for Claude Code. Then run npx skills list and report the skill name and whether it is installed. Verify the skill appears in the list before you report success.

  • Run DSH sessions, files and Git in one desktop app

    Install the packaged DSH Desktop app and work on sessions, files, Git, and terminal from one window.

    View prompt
    Using the vibeinging/dsh-desktop repository, list the installer files on its latest GitHub release for <platform> and report their names. Verify the result against the platform table in the README, which states the signing status for each platform.

  • Run several coding agents on one repo at once

    Start multiple agents on separate git worktrees so they can edit the same project without conflicts.

    View prompt
    Using the vicoa-ai/vicoa repo, set up three coding sessions on <target-repo>, each with a different task and agent (Claude Code, Codex, and Cursor). Confirm that each session runs on its own git worktree and branch and that all three appear in the Vicoa session list. Report the session names and their status.

  • Build an explorable 3D scene from a one-line idea

    Turn a short creative prompt into a Three.js scene an agent builds and checks on screen.

    View prompt
    Using the 3dviz-pro-max skill in the repository at <repo-path>, build a small fantasy village I can explore in Three.js. Choose a distinctive art direction, add a few moving creatures, and inspect the result. Report what you built and what you observed in the rendered frames.

  • Draft per-app proxy rules from plain language

    Describe the traffic you want routed and get a validated, disabled rule draft to review.

    View prompt
    Using the Vincent-Xi08/IntentRoute-AI repo, write a plain-language intent describing the traffic to route for <target application>, and walk through the OpenAI draft flow. Expected output: a list of disabled rules with process, host, port, protocol, and action fields. Verify that every rule is disabled until a user enables it.

  • Make a narrated explainer video from one topic

    Give a coding agent a topic and get a narrated MP4 with drawn scenes and subtitles.

    View prompt
    Use the explainroo repo at <repo folder> to make a short explainer video about <topic>. Read AGENTS.md and follow its steps so the agent writes script.md and scenes.js and renders an MP4. Expected output: one MP4 under videos/. Verify that the voice reads the script without wrong words before you report the file path.

  • Turn a topic into a narrated explainer video

    Give an agent a topic and get a 1280x720 MP4 with voiceover, subtitles and chapter progress.

    View prompt
    Using the anything2explainer skill in this repo, make a narrated explainer video about <topic>, in <language> and about <length> long. Stop at the four checkpoints for my approval. Verify that the final output is a 1280x720 H.264 MP4 with voiceover and subtitles, and that the research doc lists a URL for every number or claim.

  • Get clearer Claude Code answers via the Stop hook

    Install the Nopus plugin so Claude Code requests one clearer rewrite when an answer turns abstract.

    View prompt
    Using the nopus repo at Vistyy/nopus, add the marketplace with `/plugin marketplace add Vistyy/nopus`, install with `/plugin install nopus@nopus`, and set sensitivity with `/nopus:nopus-configure medium` in <project directory>. Expected output: a confirmed plugin install and a saved medium sensitivity setting. Verify that the message "nopus requested a clearer rewrite." appears after a long, abstract answer.

  • Run several coding agents side by side in one app

    Manage Claude Code, Codex and other agents as sessions in one tree, with live status.

    View prompt
    Using the VelaTerm project at https://github.com/vlinx-io/VelaTerm, install the desktop app from velaterm.com/download and start one Claude Code session and one Codex session in a project named <project-name>. Expected output: both sessions listed under that project in the session tree with a live status. Verify that both sessions keep running in the background after you switch views.

  • Debug a failed CircleCI build from your AI assistant

    Let an AI assistant read a failed CircleCI pipeline and explain what broke, using the official CircleCI MCP server.

    View prompt
    Using the CircleCI MCP server from VoltAgent/official-mcp-servers, find the latest failed pipeline for the branch <branch-name> and summarize the failing step and its error message. Verify that the error text you quote appears in the build log returned by the server before you suggest a fix.

  • Unblock a pipeline stage stalled by a stale marker

    Run a blocked stage by hand, validate it, publish it, and continue from the cursor.

    View prompt
    Using the forward-implementation-first skill in <pipeline-repo>, run the stage blocked only by a stale receipt for <stage-name> manually, validate its output against its consumer, and publish it. Report the stage output path and the cursor position after the run. Verify that no stages outside the smallest affected dependency cone were invalidated.

  • Ask weather, unit and recipe questions without an LLM

    Run the chat bar locally and get weather, unit conversions and recipes from tools, not model text.

    View prompt
    In the jev-chat repo, copy .env.example to .env, set TYPESAFE_API_KEY to <typesafe-key>, and run pnpm dev. Send the message "350F in celsius" to the chat at http://localhost:5173 and report the reply. Verify that the reply value came from the units tool and not from model text.

  • Triage a large inbox with Jev for a few cents

    Copy the email triage pattern from a listed demo and test it on your own messages.

    View prompt
    Using the repo walidboulanouar/awesome-jev-use-cases, read the Triage and routing section and the Jev API quickstart, then build a small script that sends each email in <inbox-file> to the Jev API and returns a label and confidence per email. Verify the output on 20 emails by checking that every line has a label and a confidence value.

  • Stop Claude Code from over-hardening a small feature

    Append the HERO scope block to CLAUDE.md so Claude Code stops adding unneeded hashes, flags and wrappers.

    View prompt
    Read RULES.md in the HERO-Anti-OverDefense repo and confirm that the SCOPE LIMITS block is present in <project>/CLAUDE.md, appended once and nothing else changed. Then implement <small feature> and report which of rules 1 to 9 you applied, and confirm that no hashes, feature flags or wrappers were added unless the feature needed them.

  • Turn a requirements document into an editable architecture diagram

    Upload a spec, let the assistant draft a diagram, then refine it by chat and export SVG or PNG.

    View prompt
    Using the architecture-canvas repo at https://github.com/weike-zhang/architecture-canvas, start the local workspace with python3 start.py, upload the document at <path-to-requirements-doc>, and ask the assistant to generate a layered architecture diagram. Expected output: an exported SVG or PNG of the diagram. Verify that the component count is 22 or fewer and that the component list matches the document.

  • Find a Claude Code mod that matches your task

    Filter 597 mod entries by how well each one is verified before you install anything.

    View prompt
    Using the repository wh000wh000/awesome-claude-mods, find up to five mods that match <task description>, keeping only entries whose evidence grade is at least 'its own text names a mod API, or it declares the mod capability'. Return a table with name, GitHub link, grade, and one line on what it does. Verify that each link opens to the project's own repository before listing it.

  • Pick the right official Jev SDK for your stack

    Compare the official Python and TypeScript clients and choose one for your project.

    View prompt
    Using the awesome-jev-live README, pick the official Jev SDK (typesafe-sdk-python or typesafe-sdk-js) that matches the <target language> in this project. Report the chosen SDK, its evidence grade, and one example Choice question whose answer type you verified.

  • Run your own copy of the Whirl chat app

    Clone the repo, connect Convex, Clerk, and OpenRouter, and chat with models from your own deployment.

    View prompt
    In the whirlchat/whirl repo, follow the Quick start in the README to run the web app locally using my Convex, Clerk, and OpenRouter values in <placeholder-env-file>. Report the URL the app is serving on and whether a test message to a model returns a reply. Verify that bun run dev starts without errors before reporting success.

  • Fine-tune a Hugging Face LLM with LoRA on one GPU

    Run a LoRA SFT job on a Qwen3 model with one command from a ready YAML config.

    View prompt
    In the whitecircle/halo repo, run `halo launch sft <target-config>` inside the Halo Docker image on one GPU, using examples/sft/qwen3/qwen3-4b-ultrachat-lora.yaml as the default. Expected output: a LoRA checkpoint written by the run. Verify first with `--dry-run` that the printed command matches the config path you chose.

  • Run a DeepSeek agent on your desktop without a terminal

    Install the DSHCode app, add your DeepSeek API key, and start an agent session in a workspace.

    View prompt
    Help me install DSHCode from https://github.com/whitelonng/dshcode on <my operating system> by following the README download and first-launch steps. Confirm the app opens and that an API key is saved in its settings, and report any SmartScreen or Gatekeeper warning you saw.

  • Generate images with the official Qwen-Image-2.1 base model

    Run the reference BF16 Diffusers checkpoint for text-to-image and editing.

    View prompt
    Using the wildminder/awesome-qwen-image list, load the official Qwen/Qwen-Image-2.1 model with QwenImage21Pipeline in Diffusers and generate an image from the prompt <prompt>. Report the output file path and the step count used. Verify that the image matches the prompt and that the default 40 steps without CFG ran.

  • Draw a pixel sprite live in your open Aseprite

    Have your coding agent draw a sprite in the Aseprite window you already have open.

    View prompt
    Using the MCP server from with-pebbly/aseprite-ai-artist, draw a <subject, for example a 32x32 knight> in the Aseprite window that is already open. Expected output: the sprite appears in the open Aseprite document, and the agent ends with a short list of the compromises it made. Before drawing, verify that `doctor` reports all checks passing and that Aseprite is attached.

  • Install Oh My CPA by handing the setup to an agent

    A coding agent inspects the machine, picks an install method and sets up the console.

    View prompt
    Install Oh My CPA on this machine by following https://raw.githubusercontent.com/WizisCool/oh-my-cpa/master/docs/install-for-agents.md. Report which install method you chose and why. Verify that the console answers at http://127.0.0.1:8080/omc/ before you finish.

  • Post-train SD3.5-M toward a chosen image reward

    Fine-tune SD3.5-M with Diffusion OPSD using a reward preset and measure the held-out score.

    View prompt
    Using the repo worldbench/DiffusionOPSD, set up the environment and run the SD3.5-M training preset for <reward name>. Report the training command used, the reward checkpoint path, and the final evaluation score for <reward name>. Verify that scripts/download_reward_weights.sh completed without errors before starting training.

  • Run Spark-X2.6-4B locally in Python with Transformers

    Load the 4B model in a Python script and get a chat reply on your own machine.

    View prompt
    Using the XHToken/Spark-X2.6-4B Transformers Quickstart in the Spark-X2.6 GitHub README, install transformers==4.57.1, replace the user message with <your question>, and run the script. Expected output: a text answer printed to the console. Verify that the printed answer addresses <your question> and that the script ran without a trust_remote_code error.

  • Move your full DSH setup to a new computer in one export and import

    Export your DSH configuration as one ZIP on the old machine and import it on the new one.

    View prompt
    Using the DSH Config Manager plugin in <source-machine>, export the full DSH configuration to a single ZIP, then import it on <target-machine> through the preview flow. Confirm that the MCP servers and skills are listed as restored and that no secret values were exported.

  • Plan a paper's reproduction without running its code

    Map a paper's claims to repository and environment evidence with no third-party code execution.

    View prompt
    Using the VeriRepro repo (XiantingWu/VeriRepro), install the verirepro package and run `verirepro reproduce <paper-id> --no-execute --no-llm` for the paper <paper-id>. Confirm the workspace contains repository-plan.json and environment-plan.json and that no experiment code was executed, then summarize the report.json status and the planned steps.

  • Plan a coding task in ChatGPT before Codex edits

    Use your ChatGPT web plan for reasoning while Codex keeps all the editing.

    View prompt
    Install the repo XiaoDuoYa/codex-with-chatgpt, run corepack pnpm install and corepack pnpm build, then run c2c setup and pair it with ChatGPT. Use the Codex Skill to have ChatGPT plan <task>, and report the final checklist to confirm the file read test passed.

  • Let ChatGPT edit code and run shell commands locally

    Give ChatGPT coding-grade file and shell tools on your own computer through one MCP connection.

    View prompt
    Using the OpenChatX MCP connection in the openchatx-mcp repo, open the project at <project-folder> as a Projects workspace and list its files, then run its test command through the shell tool. Report which files changed and the test result. Verify that the shell output matches what you see in the project folder.

  • Audit a clinical chat assistant's response to missing evidence

    Run the quick set to see whether a model's medical advice moves when a decisive fact changes.

    View prompt
    Use the keystone-bench repo to run the quick layer against <target model> with a judge from a different vendor, using keystone run --family all --layer quick. Confirm that runs/<run>/REPORT.md exists and check the per-family table, including whether controls pass 35 percent of the run.

  • Diagnose ACOS problems in an Amazon ad account

    Run the ACOS diagnostics Skill to find whether ACOS comes from clicks, conversion, traffic mix, or profit.

    View prompt
    Using the sealeap-amazon-skills repo, run sealeap-amazon-acos-diagnostics for <marketplace> over <time range>, with the goal of finding whether ACOS comes from click cost, conversion, traffic structure, or profit structure. Expect a list of required data, a diagnosis, the evidence gaps, and verifiable optimization options. Check that every conclusion names the data it used and marks missing data as unknown.

  • Set coding style rules for a repo from existing code

    Turn the code style of a reference codebase into a repo rule that the AI follows.

    View prompt
    Using the ai_goodpractice guide workflow, analyze the code style of <reference folder path> in depth and write it as a repo rule for <target repo path>. Expected output: one rule file describing naming, formatting and structure. Verify that each rule points to a pattern actually found in the reference folder.

  • Refactor code across a whole repo from one plain-language request

    Describe a code change in plain language and let Baize find and edit every matching file in the repository.

    View prompt
    Using the Baize CLI from the Xu123-Bob/Baize repo, run the instruction 'Find all places in <repo-path> that use requests and change them to httpx' inside <repo-path>. Expected output: a list of edited files. Verify that no file in <repo-path> still imports requests.

  • Give a custom voice agent long-term memory

    Plug Voice Mem into your own voice model so it recalls user facts and feelings across sessions.

    View prompt
    Using the VoiceMem repo at <repo path>, wire my model <model name> into a reply function with signature my_reply(text, memory_context) and pass it to VoiceMem(reply=my_reply). Confirm the sample script runs and that memory_context is non-empty after I state a fact such as a food allergy.

  • Run a local OpenAI-style LLM server on AMD

    Serve a 95 GB Qwen model on one 128 GB AMD mini PC through an OpenAI-compatible API on port 8000.

    View prompt
    In the Yamz-Labs/kyojin repo, follow doc/install.md, then download the Qwen3.8-Flash-Next pack and start tools/qwen/serve.py on port 8000 on <target host>. Expected output: the server starts and answers one OpenAI API chat request with text. Verify that the response JSON includes a choices array before reporting success.

  • Deploy a shared agent for your team in Slack and web

    Stand up a QM instance in your own cloud that teammates reach through Slack and the web app.

    View prompt
    Using the repository yc-software/qm, deploy a QM instance for <organization name> into <cloud account or target> by following its deployment guide. Report the web app address and the result of the live verification step. Verify that you can sign in to the web app before reporting the deployment as complete.

  • Compare how current LLM architectures are built

    Use the Implemented table to contrast normalization, positional encoding, and attention across models.

    View prompt
    Using the repo YeonwooSung/llm-architecture-from-scratch, compare the rows for <model A> and <model B> in the Implemented table. Output a table of normalization, positional encoding, attention type, and Mixture of Experts use. Verify each cell against the README row before reporting.

  • Find where a Claude Code session spends time and context

    Install two analysis mods to see time split by source and flag repeated or wasted context.

    View prompt
    Using the repo YeonwooSung/my-claude-code-mods, install agent-profiler and context-inspector at user scope, then run a session on <task description>. Report where time went (model wait, tools, subagents, re-reads) and which context items were flagged as waste, citing the specific tool calls or files. Verify that every cited item appears in the session output before you finish.

  • Run PRINTFILM locally with Docker in about 30 minutes

    Start the full stack on your own machine and open the user site, admin site, and API docs.

    View prompt
    In the printfilm repo, copy deploy/.env.docker.example to deploy/.env.docker, set ARK_MOCK=true and strong values for POSTGRES_PASSWORD and SECRET_KEY, then run docker compose --env-file deploy/.env.docker up -d. Output the status from docker compose ps and confirm that http://localhost:8000/api/health responds.

  • Find Jev projects that match your coding agent

    Filter the list by coding agent tag to shortlist Jev tools for Claude Code or Codex.

    View prompt
    Using the repo yibie/awesome-jev, list every entry under the Claude Code tag in its README with its name and link. Expected output: a list of 18 entries with GitHub links. Verify that the count matches the 18 shown in the Find by coding agent section.

  • Route support tickets to a department with probabilities

    Score a customer message against department options and get a probability for each one.

    View prompt
    Using the LLM2Jev repo, start the SGLang service with the model at <model-path>, then call client.systemone.create with the ticket text <ticket-text> and a Choice over the departments <department-list>. Return the probability for each department as JSON. Verify that the probabilities sum to about 1 before reporting.

  • Map a request path through a repo as an interactive story

    Generate an evidence-cited HTML walkthrough of how one request moves through a codebase.

    View prompt
    Using the fireworks-open-eli5 Skill, explain how one request moves through <target repo path>, citing real files for each step. Render it to <output.html> with the render script and confirm the file validates with the validate script. Report the file path and any claim that lacks a source locator.

  • Install the full routing suite with one command

    Add the injector, router presets, and graded mode to DSH in a single plugin install.

    View prompt
    Using the repository yjh051108/dsh-routing-suite, run the one-step DSH plugin install for the profile web, then restart DSH with the target <dsh-install-path>. Report whether a new session lists Router Standard and Router Spec (experimental), and verify the install by confirming the plugin command exits without error.

  • Turn a credited poster prompt into your own campaign visual

    Pick a tested poster prompt, swap in your own title and palette, and render a layout-first image.

    View prompt
    Using the poster prompts in prompts/gpt-image-2-5-poster-prompts.md from the awesome-gpt-image-2-5-prompts repo, take the prompt that best fits <target poster brief>, replace every curly-brace and bracketed-capital placeholder with the values in <brief values>, and return the finished prompt text. Verify that no placeholder token such as {NAME} or [BRAND NAME] remains in the output.

  • Switch Copilot Chat models without reloading VSCode

    Route Copilot Chat through a local proxy and change the active AI model in one click.

    View prompt
    Using the repo yudaprasetya007/routeVSCODE, install the VSCode extension from releases/routevscode.model-connector-2.5.0.vsix and start the dashboard with npm start, then confirm that http://localhost:5500 loads. Set the model to <target model name> from the dashboard and report the active model shown in the status bar; verify that port 20129 is listening before reporting success.

  • Review a LaTeX paper in an HTML view and record feedback

    Render your paper to HTML, comment and edit in the browser, and keep every action as a feedback file.

    View prompt
    Read and follow skills/pairtex-agent/SKILL.md in the PairTeX repo. Render the LaTeX repository at <paper-path> into a disposable HTML projection and start the local PairTeX view. Report the URL, source HEAD commit, dirty state, render command, and HTML output path, and confirm that no canonical source file changed.

  • Score an existing coding agent harness

    Run all 94 released scenarios against your product directory and get a pass rate.

    View prompt
    Use the repo YuyaoGe/doc2harness to score the product at <path-to-product-directory>. Run tools/run_production_catalog.py with --artifact <path-to-product-directory> and --output <output-dir>, then report the pass and fail counts from catalog_receipt.json. Verify that the product directory contains src/yuyao/ before running.

  • Score a website funnel and get prioritized fixes

    Get a weighted 0-100 funnel audit with a ranked list of fixes in one agent session.

    View prompt
    Using the marketing-os skill in the Yuzzyuk/marketing-os repo, run the audit module on <target URL> and return the weighted 0-100 score with prioritized fixes. Verify that the report includes a what-I-couldn't-determine section and that the score is labeled as a heuristic.

  • Generate a 4-step audio-video clip from a text prompt

    Run the DMAD 4-step LoRA on MiniMax-H3 to turn one text prompt into a 5.2 s video with stereo audio.

    View prompt
    In the Yzmblog/DMAD repo, set up the environment from the README, download the MiniMax-H3 components and the lora_critic checkpoint, then run inference.py with the prompt <your prompt> and --output-dir outputs/<name>. Expected output: an MP4 in outputs/<name>/ with H.264 video and AAC audio. Verify that the file plays and that settings.json exists in the same folder.

  • Run a browser coding workspace on a local project

    Start the web client and backend against one project folder and open it in a browser.

    View prompt
    In the zai-org/ZCode repo, run `pnpm bootstrap`, then `ZCODE_SERVER_WORKSPACE=<project-path> pnpm dev:web`. Report the web dev server URL and confirm that the backend at http://localhost:3030 responds.

  • Audit agent tools for poisoning and excess privilege

    Review an agent's tool definitions for poisoning, excess privilege, and deployment blast radius before rollout.

    View prompt
    Using the agent-surface-audit skill from the zero-lab-ai/skills repo, review the tool definitions for <agent-name> that I am authorized to assess. Return findings for poisoning, excess privilege, unsafe parameters, and deployment blast radius, each with the tool definition it cites. Verify that every finding quotes a definition I provided.

  • Scan a project's dependencies for CVEs and SBOM gaps

    Generate an SBOM for a project and correlate its components with CVE data to get exportable findings.

    View prompt
    Using the AI Security Tool repo at https://github.com/ZeroDayEvil/ai-security-tool, run its SBOM and CVE scanning workflow against <target-project-path> and export a JSON report. Expected output: a JSON file listing each component with its CVE matches and remediation context. Verify that the SBOM component count in the report matches the dependency count in the project's lock or manifest file.

  • Triage an unknown binary with an agent in one window

    Open a Mach-O, ELF or PE file and have an agent map its functions, strings and purpose.

    View prompt
    Using the Eleven app in the Zfinix/eleven repo, open the binary at <path-to-binary>, run the first look playbook, and report the main functions, notable strings and likely purpose. Verify that each claim links to a function address in the window.

  • Choose which harness part to self-update first

    Map your agent's weak spot to an update target and a short list of reference methods.

    View prompt
    Using the zgcagi/Harness-RSI repo at https://github.com/zgcagi/Harness-RSI, read the Taxonomy and Definition sections and recommend whether <my agent project> should first update interpreted targets or executable implementations. Output a short table of two or three candidate entries from the reading list with one reason each. Verify that your plan keeps the final evaluator outside the editable surface.

  • Run DSH on a local Ollama model with cloud fallback

    Add an Ollama provider to DSH so local models handle work, with cloud models as a backup.

    View prompt
    Read the README of the repository at <plugin repo URL> (dsh-local-ai) and list its install steps, the Ollama settings it needs, and how its cloud fallback is configured. Expected output: a numbered setup checklist for a DSH install on <target machine>. Verify that every step is stated in the README and mark anything that is not as unconfirmed.

  • Install DeepSeek Harness desktop on Ubuntu from .deb

    Install the Linux desktop client with dpkg and launch it from the app menu or terminal.

    View prompt
    For the repo Zhou-Yujing114514/deepseek-harness-linux, download the x64 .deb from its Releases page to <target-folder> and install it with `sudo dpkg -i deepseek-harness-*-linux-x64.deb`. Report whether the install finished without errors and whether `deepseek-harness` starts a desktop window. Verify by checking that the exit status of the install command is 0.

  • Catch new AI names the day they appear

    Get a daily report of new model, product and repo names from X, Hugging Face, GitHub and sitemaps.

    View prompt
    Using the new-term-radar repo, run the daily radar with my config at <config path> and return the new names it reports, each with the signal that caught it. Verify that every name has a source (X, Hugging Face, GitHub, sitemaps or sellers) before you list it.

  • Remove backgrounds from a whole folder of photos offline

    Install the desktop app and cut out the background from many images in one batch, with no uploads.

    View prompt
    Using the unbagrnd app from github.com/zidniryi/unbagrnd, process every image in <folder path> in batch mode and export the results as a ZIP. Expected output: one ZIP file containing one cutout per source image. Verify that the number of images in the ZIP matches the number of source images.

  • Rebuild the audit set and verify every hash

    Regenerate the 16-page demo and check that all images match their recorded SHA256 values.

    View prompt
    Clone https://github.com/znxzsy/VeriInk, create a virtual environment, install it with pip install -e ".[dev]", run python scripts/generate_demo.py, then run pytest -q. Report the number of pages and answer regions produced and whether pytest passed. Verify that examples/gallery/manifest.json lists a SHA256 for each image.

  • Start the 24-week AI engineering course today

    Clone the repo, install requirements, and run Week 1 to generate the shared dataset.

    View prompt
    Clone https://github.com/zorost/AI-Engineering-Lab into <target-folder>, install requirements.txt with python -m pip, then open curriculum/week-01/README.md. Report the Week 1 setup steps and confirm the seeded dataset was generated under data/.

  • Build and run a Gradle app on a live Android device

    Stream a device, build the debug APK, install it, and check the first screen from one conversation.

    View prompt
    Using the dsh-android plugin, call android_devices, pick the online serial, call android_boot with it, then call android_build_run with projectPath set to <path to the Gradle project>. Expected output: a result showing the debug APK installed and the app launched, plus a screenshot path. Verify that the install and launch both succeeded before reporting done.

  • Build an Xcode app in the simulator and check the result

    Have the agent build your project, launch it on a simulator, and report what the screen shows.

    View prompt
    Use the dsh-ios plugin from the ZSeven-W/dsh-ios repo to boot the simulator <udid>, build and run the project at <projectPath> with ios_sim_build_run, then call ios_sim_screenshot. Report the build result and the screenshot path. Verify that the build returned success before you report the screen.

  • Verify Evo VLM's recorded results on a CPU

    Replay the recorded evidence and run the final checks on a CPU, without model weights or new inference.

    View prompt
    Clone https://github.com/zzzz7788990213-ops/EvoVLM, enter research/evolving-vlm-inference-main, run `python3 -B -m evaluation.portable_reproduce` and then `bash reproduce.sh check`. Report the pass or fail status of each command and whether the recomputed Dev128 correct counts match the results table in the README. Do not run GPU inference and do not use `bash reproduce.sh` without a mode.

  • Rank a batch of scraped jobs into a shortlist

    Scrape job portals, then score every new posting against your fit framework in one run.

    View prompt
    In the ai-job-search repo, run /scrape and then /rank. Expect a ranked shortlist with per-job strengths and gaps, with deal-breakers applied as vetoes. Verify that the top-ranked job matches your stated deal-breakers and salary expectations.

  • Screen a compound list for drug-like properties

    Use RDKit-based skills to predict molecular properties and flag ADMET concerns in a candidate set.

    View prompt
    Using the scientific-agent-skills repo and its RDKit cheminformatics skill, compute molecular properties and ADMET flags for the SMILES in <file of SMILES strings>. Return a ranked table with the computed values and the code used. Verify that every input structure parses and that no row is silently dropped.

  • Run image and video generation fully offline

    Install Comfy UI locally, start it with --offline, and keep generation off external services.

    View prompt
    Using the ComfyUI repo at https://github.com/Comfy-Org/ComfyUI, start ComfyUI in offline mode on <target machine> and run the workflow <workflow file> with the model stored at <model path>. Expected output: generated media files saved locally with no network calls to paid API nodes. Verify that the server log shows offline mode and that no outbound requests were made during the run.

  • Resume a project on another machine with the same memory

    Run memory on a server you control so a project started on a desktop continues on a laptop.

    View prompt
    Using the ai-memory repo (github.com/akitaonrails/ai-memory), configure a second machine to use the memory server at <server-address>. Expected output: the agent on the second machine shows knowledge from sessions recorded on the first machine. Verify by asking for the open questions of the project and confirming they match the first machine.

  • Forecast many assets in one batch run

    Use predict_batch to forecast several equal-length price series at once and keep results in input order.

    View prompt
    In the Kronos repo, prepare equal-length candlestick DataFrames for <list of instrument CSV paths>, call predict_batch with pred_len=<number of steps>, and write one forecast CSV per instrument. Verify that the number of returned DataFrames equals the number of input series and that each series has the same lookback length.

  • Answer architecture questions from the graph

    Ask plain-language questions and get scoped answers instead of grepping through files.

    View prompt
    Using the Graphify-Labs/graphify repo, run `graphify explain "<concept>"` on the target project at <project-path> and list its connections. Expected output is the node's source location, community, and connections with their EXTRACTED or INFERRED tags; verify that any claim you make from an INFERRED edge is labeled as inferred.

  • Add a community bundle to a DSH web profile

    Install an external profile bundle with dsh plugin and activate it on the web profile.

    View prompt
    Using the repo 0xsline/awesome-deepseek-harness, install the bundle at <github owner/repo#ref> with `dsh plugin --profile web add "github:<owner/repo>#<ref>"`. Report the install output and whether the package declares dsh.bundle.patch. Verify by restarting with `dsh --profile web` and checking the bundle appears in Settings → Plugins.

  • Transcribe a recording with speakers and subtitles

    Turn a meeting or interview file into a transcript with speaker turns, timestamps and SRT subtitles.

    View prompt
    Using the repo 100yenadmin/fish-audio-hermes, transcribe <path to audio file> with the fish_transcribe tool, asking for speaker turns, timestamps and SRT output. Expected output: a transcript with speaker labels and an SRT subtitle file. Verify that the first and last timestamps match the start and end of the audio.

  • Teach an agent a bounded verify-and-repair workflow

    Install the algebra repair Skill so an agent checks, repairs, and reports failed steps.

    View prompt
    Using the ResiMind repo at <repo path>, install the verify-and-repair-algebra Skill into my agent and run it on the algebra problem <problem text>. Expected output: a verified solution or a list of unresolved residuals. Verify that the agent reports a failed check rather than presenting an unchecked answer as final.

  • Run Codex bash commands on Windows through Fauxnix

    Add Fauxnix as an MCP server in Codex so bash-style steps run on a Windows machine.

    View prompt
    In the 20000419/fauxnix repo context, call the fauxnix `bash` MCP tool with `find . -name '*.ts' | wc -l` in <project-dir>. Expect a single number as output with bash-style exit code 0, then confirm `fauxnix doctor` passes.

  • Benchmark BM25 baseline retrieval on GroupMemBench

    Run the baseline runner on a benchmark split to get accuracy numbers to compare against SpeakerMem.

    View prompt
    Use the SpeakerMem-R1 repo (2022hpsk/SpeakerMemR1) from the code directory to run run_baseline.py with --baseline bm25 on the groupmem benchmark, writing to <results-dir>. Expected output is question-level results and a metrics summary in that folder. Verify that the run finished without missing-data errors and that the metrics include accuracy.

  • Test an AI's code rewrite against the original before merging

    Run a candidate and a reference implementation on shared inputs and catch any disagreement.

    View prompt
    Using the reverify repo at 2akouwu/reverify, run its equiv check with --lang python to compare the AI-rewritten <function file> against the original reference over shared inputs. Report the result and, if refuted, the input and both outputs, and do not accept the rewrite unless the check agrees.

  • Map where AI models agree and disagree on a research question

    Run a panel on a contested question and read the consensus, disagreements, and rankings.

    View prompt
    Using the a1exsun/dsh-council repo in DSH Web, run /council on this research question: <question with the scope and the sources you already hold>. Return the consensus, the disagreements, and the average rankings. Verify each cited claim against the source material before using it.

  • Build a Jev pull request grader in Codex

    Install the skill in Codex to build a Score-based check that grades pull requests.

    View prompt
    In this repo, use the building-with-typesafe-jev skill to write a script that sends a pull request diff and its spec to Jev as a Score question on a described scale, then flags results below a threshold. Show the question text and the threshold. Verify the script handles the Score result as a value on the scale you defined.

  • Hand a task to a bot from WhatsApp or Telegram

    Link a messaging app to a bot so you can give it work from your phone.

    View prompt
    Using AbacusAI Bot, link a messaging app for <user's account> to a bot named <bot name>, approve only <sender>, and keep risky tool calls waiting for desktop approval. Send one test request and report the reply. Verify that messages from unapproved senders are recorded but do not start work.

  • Watch one LIBERO task learn across retry attempts

    Run a single LIBERO task with a persistent simulator and see how failures change the next attempt.

    View prompt
    In the EvoBot repo at <repo path>, run the task libero_spatial:0 with scripts/ipc_learn.py and --max-attempts 10. Report how many attempts were used, whether the task passed, and the failure reasons you saw. Verify that the progress entry for libero_spatial:0 matches the outcome you report.

  • Schedule a saved prompt to run as a new session

    Run a saved prompt hourly, daily, weekly, on a cron expression, or once, with notifications.

    View prompt
    Using the abcwyc/pi-agent-desktop README, describe how to set up a daily scheduled task that runs a saved prompt for <project-name>. Expected output: the schedule settings and the default tool mode. Verify that the README states the app must stay open for runs to happen.

  • Scan an x86-64 ELF for heap and format string bugs

    Flag allocation overflows, use-after-free, and unsafe printf-family format arguments.

    View prompt
    Using the Ablation repo at ~/ablation, run the Heap Vulnerability Scanner and Format String Scanner on <binary path>, which is an x86-64 ELF. Output a grouped list of findings with function name, address, and finding type. Verify that each finding names the specific call site and that heuristic results are labeled as heuristics.

  • Add a WebGL glass pass to a launch film

    Render a second version of a launch film with refractive 3D glass shapes floating through each scene.

    View prompt
    In the repo AbubakrChan/product-launch-motion, add the optional WebGL glass pass to the launch film for <target website URL>. Expect a second 60 fps MP4 with refractive 3D shapes through every scene. Verify both films have the same length and the glass version keeps the beat-synced sound.

  • Have an AI agent build and open a 3D animation

    Paste one prompt into a coding agent and get an installed, rendered 3D animation back.

    View prompt
    Follow https://manimgx.academa.ai/llms.txt, install ManimGX, and make a 3D animation of <topic>. Expected output: a rendered MP4 that you open for the user. Verify that the video shows the <topic> scene from start to end.

  • Run several agents and act only when one needs you

    Use the attention queue to see the moment an agent needs input across parallel sessions.

    View prompt
    Using the acryl repo at github.com/acryldev/acryl, launch two Claude Code sessions in the project at <project-path> inside ACRYL. Report which session the attention queue flagged first and verify that the queue updates when one session asks for input.

  • Turn small labeled issues into reviewed draft pull requests

    Let scheduled agents implement charter-allowed issues on claimed branches and open draft PRs for review.

    View prompt
    In the addyosmani/factory setup of <target-repo>, pick one issue labeled factory:ready-to-implement and run the implementation stage on it. Expected output: a draft pull request with its gate results and verifier verdict. Verify that no merge was performed and that the PR is still open as a draft.

  • Map low-privilege to Domain Admin attack paths

    Run /ad-recon and /ad-attack-paths to collect the directory graph and reason about paths to Domain Admin.

    View prompt
    Using the Claude-AD repo (ADScanPro/Claude-AD), run /ad-recon and then /ad-attack-paths against the authorized domain <target-domain> starting from the low-privilege account <low-priv-user>. Expected output is a ranked list of candidate paths to Domain Admin with the technique and detection events for each step. Verify that no step is executed or marked as executed without explicit human confirmation.

  • Recommend an MCP server, tool, or model to UNIGIT

    Submit a structured resource issue so a useful public capability can be considered.

    View prompt
    Using the adtexterry-lgtm/unigit-ecosystem README and docs/OPEN_SOURCE_SCOPE.md, draft a resource recommendation for <resource name> that follows the resource issue form. Expected output: a short draft with the resource, its public source, and the real work it supports. Verify that the draft contains no credentials, customer data, or private material.

  • Publish agent-written specs to your team via Git

    Promote the specs an agent wrote into the shared folder so teammates receive the same project knowledge.

    View prompt
    Using the Operator Memory repo (https://github.com/aerovato/operator-memory), ask the agent in <project-path> to write a spec for <feature-name> and promote it to Shared. Expected output: a document under .operator-shared/ describing that feature. Verify the file is present and tracked by Git before you push.

  • Preview, then install ECC into Claude Code and Codex together

    Use the multi-harness wizard to set up two coding agents in one reviewed flow.

    View prompt
    Using the ECC repo at github.com/affaan-m/ECC, preview a guided install for Claude Code and Codex with `npx [email protected] install --guided` and report the install channel and destination for each harness in <project-path>. Verify that the preview shows no writes before you confirm.

  • Run Comma locally with a mock model for testing

    Start the backend and Web client without a model key and run the test suites.

    View prompt
    In the AFK-surf/Comma repository, install dependencies with pnpm, start the local stack with make dev, and run make test-clients and make test-systems. Report which suites pass and which fail, with the failing test names. Verify that the mock model is in use by confirming the README says make dev uses a deterministic mock model.

  • Review a GitHub pull request with findings and reasons

    Run the review specialist on a PR and get findings with file locations and fixes.

    View prompt
    Use the CodeAF repo at Agent-Field/CodeAF. After installing it, run `/review <owner>/<repo>#<number> focus on retries` in the chat. Expected output: a review report with findings, file locations, reasons, suggested fixes and coverage, in Markdown or JSON. Verify that the code was not changed and that the coverage section lists what was not analyzed.

  • Log in from a Bitwarden vault and stop before submitting

    Fill a login form from a vault item, then pause for confirmation before any submit.

    View prompt
    Use the fastbrowse repo to sign into <start URL> with the Bitwarden item <vault item name> and report the page the run stops on. Run `uv run fastbrowse "<task>" --start <start URL> --bitwarden <vault item name>` without --authorize. Verify the result reports needs_confirmation and that no submit happened.

  • Set up an OpenAI-compatible provider profile for Codex CLI

    Add a provider profile, let the app check it with a real request, and keep native config in sync.

    View prompt
    Using the Agent Launcher repo at https://github.com/agent-launch/agent-launcher, create an OpenAI-compatible provider profile named <profile-name> for Codex CLI with endpoint <endpoint-url> and model <model-name>, then run its connectivity check. Expected output: a pass or fail result for endpoint, credentials, model, network, and account status. Verify that the masked native config preview shows no plaintext key.

  • Choose a workflow automation tool that includes AI steps

    Match scheduled and event-driven automation tools to your needs and license rules.

    View prompt
    Use the Workflow automation platforms section of the Agenta-AI awesome-ai-agent-platforms repo to find entries that mention AI steps or AI agents. Output a comparison of name, license, and hosting for the three best fits for <workflow to automate>. Verify that each license note matches the project's GitHub LICENSE file before reporting.

  • Invite a new agent to the group from a chat

    Let one connected agent create a short invitation link for another agent after you confirm the code.

    View prompt
    Using the AgentPeerChat CLI, create a 10-minute invitation for <new-agent-name> and return only the link and the pairing ID. Verify that the invitation is open, and confirm the invitee's verification code with me before approving.

  • Deploy a shared Nautilo server for your team

    Host your own Nautilo on a datacenter machine or VPS so your team shares one Room.

    View prompt
    Using the agentsea/nautilo repo and its Linux server deployment guide, prepare a deployment plan for <server host> that lists required model API keys, access decisions, and security steps. Output a checklist and verify that the plan covers the security and privacy guide before any server change is made.

  • Sort and answer your support inbox on a schedule

    Connect a support mailbox, give it to a team member, and have it sort new mail hourly.

    View prompt
    Using the repo agentvivekkumar/dontbemichael, connect the support mailbox <support mailbox address> and assign it to the Customer Support team member with Draft only sending. Report how many new messages were sorted in the first run. Verify that the mailbox shows as watched by that team member on its Access tab.

  • Run a quarterly personal retreat in your vault

    Use the Personal Retreat template to review the quarter and set the next one.

    View prompt
    In the Compass vault at <vault path>, read 02 Retreats and the wheel_* properties in Meta/Compass Config.md, then compare the two most recent YYYY-QN Personal Retreat notes. Expected output: a table of wheel areas with their scores for each quarter and the change between them. Verify that you did not edit any retreat text, since AGENTS.md says not to rewrite journal or planning text.

  • Serve a developer seat from a local GPU model

    Connect a local Ollama model to the senior_developer role using shadow-worker.

    View prompt
    Use the repo AhmadHassan-BTed/AutoSwarm-Shadow-Adapter to connect a shadow-worker for the senior_developer role at <server URL> using the Ollama provider with model llama3.3:70b. Expected output: a running worker that reports the tasks it claims and the deliverables it submits. Verify that the worker logged in with the account <username> and that a claimed task reached the submitted state.

  • Find the communities where your users already talk

    Map the named places your target users gather, with links, and launch examples.

    View prompt
    Run research-the-market in the gtm-cofounder skills for <product name> and <target user role>. Expected output: docs/gtm-cofounder/market-research.md with linked communities ranked by fit and the rules each room has for self-promotion. Verify that every finding has a link and is tagged [researched], not treated as a real user statement.

  • Get a daily shortlist of scored job postings

    Let the optional job agent search once a day and keep the best matches for your review.

    View prompt
    Using the AienTech/dossier repo, set up its job agent with the job source <JSearch, Adzuna or Bundesagentur für Arbeit> and the search <search terms and location>. Return the top postings from the Agent screen with their scores and reasons. Verify that the agent has not sent or applied to anything, since the README says it never does.

  • Turn GEO gaps into tickets and check that fixes worked

    Create implementation tickets with acceptance criteria and let re-crawls and sampling decide if each fix is done.

    View prompt
    Using the geolook repo at <repo path>, read the open implementation tickets for <brand> and draft the acceptance criteria check for each one. Output a list with ticket name, current measured value, target value, and pass or fail. Verify that the list matches the progress bars shown in the Action area.

  • Read a logged-in dashboard page step by step

    Let an agent open, read and screenshot a signed-in page one command at a time.

    View prompt
    Using the Chrome Relay repo at aindeev/agent-chrome-relay, open <URL> with chrome-relay open, read it with chrome-relay snapshot --text, and report the value of <element or text>. Expected output: the text found on the page plus the current URL. Verify the URL matches <URL> before reporting.

  • Record a 28 second film of a machine for social feeds

    Generate a machine and record a numbered-beat film with music, sized for a feed post.

    View prompt
    Using the repo AirsupHQ/machine-skill, build a watch movement page for <machine description> and record a 1080 x 1350 film with `scripts/record.mjs`. The expected output is an MP4 in out/ of about 28 seconds. Verify that `scripts/pinkscan.mjs` reports no pink frames and that the command exits zero.

  • Work on a project in one split window with files, terminal, and browser

    Open a project as a dockable workspace that combines file explorer, terminal, browser, and chat in one layout.

    View prompt
    Using the repo Aisland-SJL/dsh-worktable in DeepSeek Harness, create a project for <project-folder> with a split layout that includes file explorer, terminal, and browser panes. Report the layout name and pane list. Verify that reopening the project restores the same panes and widths.

  • Test whether an agent change helps, task by task

    Compare two agent versions on the same tasks with a paired sign test instead of one total score.

    View prompt
    Use the alanhuangyoo/crux repository benchmark folder. Run the same Terminal-Bench 2.1 dataset and model for two agent versions, <baseline> and <changed>, then compare them task by task with the paired sign test. Output the per-task outcome counts and the test result, and verify that both runs used the same model and task set.

  • Let Claude Code pick a tool for a task with no official API

    Install the plugin so Claude Code can search the index and choose a tool for a closed system.

    View prompt
    Using the reverse-engineered plugin from alexgaoth/awesome-reverse-engineered, search the index for tools that control <device, app or protocol>. Rank the matches by stars, activity and license, read the top README, and return a short recommendation. Verify that the recommended project has a license before you propose using it.

  • Make a set of brand illustrations for your website

    Generate a hero image and matching spot art in one chosen style, as transparent PNGs at any size.

    View prompt
    Using the anidoodle repo, draw a hero illustration for <page name> in the <style name> style at 1600×900, plus three spot illustrations for its features. Return transparent PNG files and confirm all four share the same style.

  • Switch Claude to terse mode for heads-down work

    Use the Spartan style to get blunt, compressed replies during focused coding with no conversational padding.

    View prompt
    Using the repo alexgreensh/attention-span, install the attention-span plugin in Claude Code and use the Spartan style with /spartan, then ask Claude <your coding question>. Expected output: a terse, imperative reply with arrow-marked points and bold words, and no warm transitions. Verify that the reply contains no filler sentences before the answer.

  • Find what blocks a clone from launching

    Get a ranked list of integrations, licenses and approvals a rebuilt product would need before launch.

    View prompt
    Using the res skill in the alextnetto/res repo, study <product> with a charter focused on production barriers for the <market> market, and do not ask me questions. Expect clone/barriers.md inside re-<product>/. Verify that every barrier lists severity, lead time and a mitigation with a source ID.

  • Have a coding agent build a demo clip for your product

    Point Claude Code or Cursor at your product and let the skill file drive a shot list and render.

    View prompt
    In the repo Alexwtlf/agentic-product-demo, read AGENTS.md and the product-demo skill, then read the product at <product-path> and propose a shot list before writing code. After approval, build a composition named <name>, render it, and output out/<name>.mp4 and out/<name>-preview/contact.jpg. Verify that the frame gate passes and that button labels match the real UI.

  • Review and revert agent edits from shadow history

    Compare what an agent changed in a file or tree and revert the parts you reject.

    View prompt
    In the project <project>, open the shadow history for <file path> in Flare and compare the latest snapshot with the one before it. Expected output: a short plain-language list of what changed in that file. Verify the list matches the task card the agent was given before you keep the change.

  • Keep a coding session running during provider outages

    Set a fallback model list so FCC moves to your next model when a provider fails.

    View prompt
    In the repo Alishahryar1/free-claude-code, configure two providers and an ordered Fallback Models list in Model Config, then start `fcc-codex`. Expected output: a coding turn completes even when the first model is unavailable. Verify by checking the server log for the fallback model name.

  • Check changed code lines against plain-English rules

    Flag rule violations on the lines a change adds, using rules written in plain English.

    View prompt
    Use the softlint repo (https://github.com/blazejkustra/softlint) to check the diff of <branch-name> against these plain-English rules: <rules>. Return each finding with its file, added line, and the rule it breaks. Verify that every finding points to a line added in the diff.

  • Delegate a terminal task to a chosen agent

    Send a command-line job to a specific agent backend and collect normalized results.

    View prompt
    Use the LongHorizon-Harness repo at <repo path> to run a terminal task for <goal> with the --agent opencode option. Expected output: the normalized result file or summary for <goal>. Verify that the tests or commands named in the goal were actually executed and passed.

  • Build a feature in Claude Code with a spec you approve first

    Install Old Coder in Claude Code so the agent writes a test plan, waits for your yes, then ships with evidence.

    View prompt
    Using the old-coder skill in the <project-path> repo, implement <feature-description>. First write the SPEC with concrete must and must-not examples and stop for my approval. After coding, produce an EVIDENCE report listing each check as pass, fail, or unverified, and confirm it came from a fresh run.

  • Prepare for AI engineer interviews with course material

    Use the interview module, glossary, and FAQs to drill core AI engineering terms.

    View prompt
    Read the README of amitshekhariitbhu/ai-engineering-course, take the terms in the Key Concepts Glossary, and create a quiz of 10 questions for <target role>. Output each question with the module it comes from, and verify that every answer points to a section that exists in the README.

  • Plan a RAG architecture for document Q&A

    Use the RAG sections to choose chunking, search, and reranking for a document assistant.

    View prompt
    Using the repo amitshekhariitbhu/ai-system-design, read the RAG section and produce a retrieval design for <target>, covering chunking, hybrid search, and reranking. Output the design as a Markdown document with one section per choice. Verify that each choice cites the README section it came from.

  • Pick a KV cache memory technique for long prompts

    Compare KV cache compression, PagedAttention, GQA, and Flash Attention to choose a memory approach.

    View prompt
    Using the amitshekhariitbhu/llm-inference-engineering repo, compare the KV cache techniques for the workload <workload description> and output a table with one row per technique. Verify that each row matches the 'Comparison of the approaches' and 'When to use which one' sections of the KV Cache Compression post.

  • Give Codex CLI control of desktop apps on macOS or Linux

    Register LCU with Codex CLI so the agent can see windows, click, type, and capture screenshots.

    View prompt
    Using the amontlabs/lcu repo, set up LCU for Codex CLI on this machine by following docs/INSTALLATION.md. Ask me to approve the desktop app named <app name>, then have the agent list its windows and take one screenshot. Report the setup result and confirm the screenshot was taken.

  • Review your account activity through the agent's browser

    Have the agent open your signed-in account, read stats and pull out key comments.

    View prompt
    In the OpenGhost app from https://github.com/ANDRETRIPOL/OpenGhost, with the browser panel signed in to <site>, report the view counts of my three most recent posts and list the comments that contain suggestions or bug reports. Expected output: a short list with each count and each relevant comment. Verify each number against the page before you report it.

  • Delegate a task to an agent and check the result

    Hand a settled spec to a coding agent, then compare the delivered work against each constraint.

    View prompt
    Using the Intent-Router skill in this repo, take the settled IntentSpec for '<task>' and carry it out as written. Then run the Intent check against the delivered code. Expected output: one line per constraint, each met with a code pointer or not met. Verify that the check result is saved in the same .intent/ file.

  • Map a Windows PE binary's protections and key functions

    Get architecture, protections, and a function list for a PE file in one agent session.

    View prompt
    Using the seep MCP tools in the Seep Reverse Lab workspace, triage <path-to-pe-file> with seep_r2_info, seep_r2_functions, and seep_r2_decompile in summary mode. Expected output: architecture, bitness, protection flags, and the top functions by interest. Verify that the protection flags match the seep_r2_info output.

  • Hand multistep code searches to a subagent

    Call the built-in general subagent with @general to run complex searches across a repo.

    View prompt
    In the anomalyco/opencode CLI, send a message beginning with @general asking it to find every place <symbol-or-setting> is read or written in <project-path>. Expected output: a list of file paths and line references with a one-line note on each. Verify by opening two of the listed files and confirming the references match.

  • Run a small open decision model locally

    Pull a small open-weight decision model into Ollama and score your own options on your own machine.

    View prompt
    Using the Open Models section of github.com/AnotiaWang/awesome-decision-models, pick one model that the README lists as available in Ollama and run it locally on the sample state in <sample-file> with the options in <options-file>. Expected output: one probability per option. Verify the license of the chosen model in its model card before you use the output in a product.

  • Preview camera layouts in a browser GUI

    Run the Gradio GUI to inspect inference results and visualize target views with Rerun.

    View prompt
    In the 4DAnyone repo, run app.py with --output_dir set to <output_dir> and --server_port 7860, then confirm the Gradio page loads at http://127.0.0.1:7860. Expected output: an interactive view of the inference results. Verify that the output directory contains cameras.json and videos/ before launching.

  • Optimize a retrieval workflow's pipeline.json and node code

    Have agents edit pipeline config and node scripts until a workflow scores better on your data.

    View prompt
    Using the AntOmniEvo repo (ant-research/AntOmniEvo), evolve the workflow at <pipeline-dir> where pipeline.json and nodes/*.py are the tunable artifacts, scored by an Evaluator returning 0 to 1. Expected output: the best candidate's pipeline directory and changelog. Verify that each changed file in the best candidate traces back to a recorded failure.

  • Build an editable LEGO MPD from a JSON plan

    Have an agent turn a model idea into a JSON plan, then build and review an editable MPD.

    View prompt
    Using the ldraw-nova repository and its instructions.md, write a JSON plan for <model idea> and save it as output/<model-name>.plan.json. Run ./ldraw-agent build on that plan, then ./ldraw-agent review on the generated MPD. Report the path of the editable MPD, the checks that passed or were skipped, and the preview folder; verify that the MPD exists before reporting.

  • Delegate routine coding tasks from the terminal

    Hand repetitive edits and small fixes to Claude Code using plain-language requests.

    View prompt
    In the project at <project-path>, start Claude Code with `claude` and ask it to <routine-task-description>. Expected output: the listed edits made to the project files. Verify by searching the project for the old pattern and confirming it no longer appears where it should be changed.

  • Build a plugin in the standard layout for submission

    Scaffold a Claude Code plugin with the required manifest and submit it for review.

    View prompt
    In the anthropics/claude-plugins-official repo, scaffold a plugin folder named <plugin-name> that follows the standard structure with .claude-plugin/plugin.json and README.md, using /plugins/example-plugin as the reference. Output the list of created files. Verify that .claude-plugin/plugin.json exists and is valid JSON before preparing the submission.

  • Analyze financial data by chat with interactive charts

    Ask questions about financial data in chat and see interactive visualizations as answers.

    View prompt
    Work in the anthropics/claude-quickstarts repository. Open the financial-data-analyst quickstart, follow its README to install dependencies, set the Claude API key and start the app. Ask it one question about the sample financial data and report whether it returned an analysis with an interactive chart.

  • Run the book's web reader on your own machine

    Start the Vite and Vue reader locally to browse the architecture book without the hosted site.

    View prompt
    In the antinomie-lab/pi-book repo, go to the web/ folder and run the install and dev commands from its README. Report the local URL the dev server prints and confirm that the Chinese chapter text renders from agent/ without errors.

  • Build a product display scene from a short brief

    Turn a written layout brief into a pedestal, camera, lights and matte material in Blender.

    View prompt
    Using the mcp-for-blender-pro add-on in Blender, build a product-display scene with a pedestal, one camera and three lights using the add_cube, add_cylinder, add_camera, add_light and set_material tools. Return the list of created object names. Verify with viewport_screenshot that the pedestal has the matte blue material.

  • Build a product-display scene from a text brief

    Turn a short creative brief into a basic product-display layout with lights, a camera and materials.

    View prompt
    Use the mcp-for-blender-pro assistant in Blender to build a product-display scene for <product name> with a pedestal, a camera, three lights and a matte blue pedestal material. Expected output: a viewport scene containing those objects. Verify by listing the scene objects and confirming the pedestal has the blue material.

  • Resume a project in a new agent or chat without starting over

    Use the committed index so a new agent, host, or conversation picks up the system context in one read.

    View prompt
    Using only the AOCI index in <project-path>, describe the system, report your mastery of each area as a percentage, and say whether you can take over development. List any area below 80 percent and the source files you would read first.

  • Hand the companion a task and approve each step

    Ask it to handle something for you, then approve or reject each side effect before it runs.

    View prompt
    In the Apeireth repo at <repo path>, check that a delegated task on <target machine> pauses at an approval card before any side effect. Expected output: a pending approval with no change made yet. Verify that the target file is unchanged until you approve.

  • Analyze a project or documents with one stateful agent

    A single ReAct agent reads files, runs commands, and writes deliverables inside a sandboxed task folder.

    View prompt
    Using the FrontierAgent repo at <repo path>, run react mode with --cwd set to <target folder> and attach the documents <document paths> with --input. The expected output is a written summary of the files in /outputs. Verify that the agent only reads from /inputs and that each command it ran appears in the trace.

  • Improve an existing app screen against category leaders

    Give an agent a screenshot, code, or Copy Screen ID and have it rebuild the screen to a higher bar.

    View prompt
    Using the appllama/appllama-skills repo, take the screen at <screenshot, code path, or Copy Screen ID> and improve it against the top-grossing apps in its category through the Appllama MCP. Output the revised screen code and a list of changed patterns, and verify the result in the simulator before reporting it.

  • Give a coding agent a fast local browser for page tasks

    Let Claude Code, Codex or Cursor handle planning while a local engine handles clicks, selects and scrolls.

    View prompt
    Using the fast-browser-use skill in <repo path>, complete the browser task <task description> on <start URL>. Return the step-by-step execution trace and the final page URL and title. Verify the final URL matches <expected URL> before marking the task done.

  • Point Codex CLI at a Kaggle-hosted open model

    Use the public endpoint from a Kaggle TPU session as the backend for Codex CLI.

    View prompt
    In the ARahim3/kaggle-tpu-lab repo, read the Codex CLI lines in the <model> folder README, run that model's notebook on Kaggle, and configure Codex CLI with the printed URL and API key. Expected output: a Codex CLI answer to a test question served from the TPU. Verify the request reaches the Kaggle endpoint, not a default provider.

  • Catch missing service dependencies before a plugin runs

    List what each plugin needs and provides, and fail early on a service nothing provides.

    View prompt
    Using the repo arcships/rutis, run `npx rutis-host check` inside the project at <target>. Expected output: a list of each plugin's dependencies and provided services, or a failure naming a service nothing provides. Verify that adding a provider for the missing service makes the check pass.

  • Move every app screen onto a design system safely

    Migrate all routes with parallel workers, each checked against its before screenshot.

    View prompt
    Using migrate-design-system from the arla6ka/design.how skills in this repo, run audit mode on <target app path> and write the results under .design-system/. Expected output: a list of screens and values to change. Verify that no commits were made in audit mode.

  • Answer agent prompts from your phone

    See which agents are waiting for input and reply to them from a phone.

    View prompt
    In the arronKler/pairfob repo, read the section 'What you can do from the phone' in README.md. Summarize how the Needs you strip and the Auto, Control, Terminal and Chat modes work, and name the one mode to use for a full-screen TUI such as vim. Verify your answer against the README text.

  • Bulk export a channel's transcripts for a search index

    Collect video IDs from a channel or playlist and export transcripts in retrieval-sized chunks.

    View prompt
    Using the youtube-skills repo, list all video IDs for <channel or playlist>, then submit one bulk transcript job with segment=1000 and format=json. Report the job ID, the number of videos accepted and the credits charged, and confirm that each chunk has a start timestamp.

  • Download and benchmark a pinned catalog model

    Let the tool fetch a verified model, start llama.cpp, run the replay, and stop the server.

    View prompt
    Using the agentperf-local repo from ArtificialAnalysis, run `agentperf-local managed-run` with --profile-id qwen38-27b-q4-k-m and --framework llama-cpp, writing to results/<name>. Expect a summary.json and a server log in that directory. Verify that every model file passed its SHA-256 check and that the run is not marked reduced.

  • Redraw existing Mermaid or draw.io diagrams in See Code style

    Convert old diagram files into See Code diagrams, one per file, with an index page to browse them.

    View prompt
    Use the SeeCode skill from the Aryanutkarsh/SeeCode repo to redraw every diagram in <path to source file> as SeeCode diagrams in a folder. Expected output: one HTML file per diagram plus index.html. Verify that the count of diagrams matches the count of diagram blocks in the source and that the report lists anything dropped.

  • Test whether an evolved skill actually improved results

    Use paired per-task comparison with an exact binomial p-value to judge a skill change.

    View prompt
    In the ashutoshsinghpr7/wikiskill repo, run `wikiskill compare` on the demo workspace after an evolve run. Report the per-task wins, losses, ties and the two-sided exact-binomial p-value. Verify that the comparison used the same validation tasks for both the baseline and the evolved skills.

  • Watch the memory write, index, inject and recall cycle offline

    Run the bundled demo script to see how memories are written, indexed, injected and forgotten.

    View prompt
    Clone the dsh-auto-memory repo into <target-folder>, install its dependencies, and run node scripts/demo.mjs. Expected output: a log of write, index, inject, recall and forget steps with no API key requested. Verify the script exits without error.

  • Build a course from one expert's blog or Substack

    Name a specific expert and get a course built from their own published writing.

    View prompt
    Using the assafkip/claudemy skill, ask Claude Code to teach <topic> from <expert>'s writing. Expected output: a lesson series, cards, and a playbook based on that expert's blog or Substack. Verify that every cited link points to a page the expert published.

  • Find stuck or looping agents before they waste time

    Spot agents that are slow, quiet, failing or repeating work using the badges on each tile.

    View prompt
    In the repo Atoll92/agent-standup, open the live call for my running Claude Code or Codex session. Report each agent that shows a ⏳, 💤, ✗ or ♻ badge and the calls listed when you hover over that badge. Verify each badge against the session's real tool calls before you act on it.

  • Turn a scan into an HTML report with fix steps

    Generate a self-contained HTML report with plain-language remediation for each finding.

    View prompt
    Run `npx geiger-scan --html report.html` on <machine name> and confirm that report.html was created as a self-contained file. Return the count of findings that include a What to do block and verify that no credential value appears in the file.

  • Block Claude Code from reading PDFs and images

    Add a PreToolUse hook that denies the Read tool on PDF and image files.

    View prompt
    Using the atria-asi/Atria-Dawn README, install the Claude Code PreToolUse hook that blocks Read on PDF and image files. Save the script to <target-dir>/block_pdf_image_read.py and register it in ~/claude_dir/settings.json. Expected output: a denied Read call for a PDF path. Verify by asking Claude Code to read a .png file and checking that the denial reason appears.

  • Build a circuit and compare two versions of it

    Use a circuit agent in CircuitJS to change a resistor and overlay the results.

    View prompt
    Using the CircuitJS harness from the openharness repo, build a simple RC filter for <target-cutoff-frequency>. Change one resistor, overlay the two traces, and report the measured difference in cutoff frequency. Verify that both circuit versions are saved in the workspace.

  • Map a codebase so Claude finds callers in one call

    Index an existing project so Claude can see what defines, calls or imports a symbol.

    View prompt
    In the repo <repo-path>, after running claude-db scan, ask Claude Code who defines, calls and imports the symbol <symbol-name>. Expected output is a list of definition and call sites. Verify at least one listed site with grep before trusting the result.

  • Move an existing CLAUDE.md into JEVMEM.md lines

    Preview and apply the rules from a hand-written CLAUDE.md as Jevmem memory lines.

    View prompt
    In the jevmem repo at <project-folder>, run `jevmem import` and report the lines it would add from CLAUDE.md. Expected output: a list of candidate lines and no file changes. Verify that after running `jevmem import --apply`, JEVMEM.md contains those lines.

  • Run a multi-step browser task on your Mac

    Give the agent a goal in plain English and let it click through a site for up to a set number of steps.

    View prompt
    In the typesafe-computer-use repo, run `uv run clicker "<goal>" --act --steps 20 --delay 3` and report the final answer and the stop reason. Verify that the run folder was written under runs/ and that the stop reason is one of done, low confidence, a stall, or the step limit.

  • Find what breaks before changing a function

    Ask an agent which files and tests a change to one function can affect.

    View prompt
    In the <repo> project, use the axiomcode impact tool on <function> and list the files that must change, the entry points that reach it and the test files that reach it. Expect a numbered list with file and line for each item. Verify that the output ends with a verified line showing the edges were looked up again.

  • Stop an agent from closing unfinished tasks

    Make todo close refuse until criteria are checked, evidence is recorded, and the gate is clean.

    View prompt
    In the procoder-enabled repository at <repo-path>, close the todo item <item-id> only after its acceptance criteria are checked and the gate is clean. Report the refusal text if the close is refused. Verify that the item shows as closed only when the gate result is clean.

  • Load the Brazilian legislative model and generate text

    Download the published safetensors model and tokenizer from Hugging Face and run its inference code.

    View prompt
    Using the repo https://github.com/BaruqueRodrigues/llm-legislativo and the Hugging Face model BaruqRodrigues/llm-legislativo, generate a short Portuguese text starting from the prompt <prompt>. Output the generated text and the exact command used. Verify that the tokenizer round-trips the prompt before generating.

  • Let your coding agent read and edit design screens

    Connect Claude Code to Quilt over MCP so it can inspect and patch screens without losing others' edits.

    View prompt
    Using the quilt MCP server at http://127.0.0.1:3100/mcp, call get_outline, then get_screen for the screen named <screen-name>, and use patch_screen to change <change-description>. Report the new revision ID. Verify the write succeeded and that a stale expectedRevisionId returns a 409 response.

  • Let an MCP agent edit the same timeline you see

    Connect a coding agent over local MCP so it updates Editor timelines, overlays, and captions in your open project.

    View prompt
    Using the BeatDesign MCP tools in <repo path>, open the latest project, add the clips in <clip folder> to a timeline, place the logo overlay at <logo file>, and style the SRT captions. Confirm the changes appear in the browser Editor and report what changed.

  • Make a second style edition of a release video

    Re-render an existing release video in the glass keynote style without touching the first edition.

    View prompt
    Using the motion-video skill from bestagentkits/motion-video-skill, create a glass keynote edition of <release name> in a new project directory named <new-project-name>, leaving the existing comic edition untouched. Expected output is a rendered 1920×1080 30 fps video in the new directory. Verify that the original project directory has no changed files.

  • Produce ebook and print files for a KDP title

    Create EPUB, print PDF and editable DOCX outputs for a Kindle or paperback edition.

    View prompt
    Use the Beyondwords skill from beyondtahir/beyondwords to prepare files for the manuscript at <manuscript path> in <trim size> print format. Return an EPUB, a print PDF and an editable DOCX, plus a dimension check report. Verify that the print PDF matches the selected trim size before reporting success.

  • Let a coding agent pull ranked context over MCP

    Connect an MCP-capable coding agent to the code graph so it asks before it searches.

    View prompt
    In the bgts-context-engine setup, make sure the repository at <target repo path> is indexed, then start the MCP server with bce serve-mcp and connect the agent to it over stdio. Expected output: the agent gets a ranked answer for the task <task text> before any grep or glob call. Verify that the agent's first tool call is to the context tool and that the returned symbols include the files the task changes.

  • Translate a text string from the command line

    Send a sentence to the free API and get a translation back in one command.

    View prompt
    Use the repo at https://github.com/bilibili/Index-Translate. Run `python inference/llm/call_api.py "<text>" --target <language_code>` and return the translated output. Verify that the output is in the requested language and keeps the meaning of the source text.

  • Watch one agent rollout in a browser

    Run a single BEHAVIOR instance and open the live interface through an SSH tunnel.

    View prompt
    In the RoboHarness repo, start a single-instance trial of task <task id> with --instances 301 in a new run directory that does not already exist. Report the path of instance_301/ and the last lines of its error log. Verify that the run directory is new before launching.

  • Make nine game-ready props from one prompt

    Generate one sheet of props and split it into separate named 3D props with LODs and compressed textures.

    View prompt
    Using the AssetFurnace repo at <install folder>, generate a prop sheet from the prompt '<prompt>' and split it into nine props. Verify that nine separate named props are produced, each with three LOD levels.

  • Hold expensive Claude Code messages before they go

    Guard holds a message to an idle long conversation once, with its cost, and a cache countdown shows time left.

    View prompt
    In the optimaizr repo (github.com/blendbunjaku/optimaizr), run `optimaizr guard on` and then `optimaizr guard` on this machine. Report how many messages were held and the cost each would have written. Verify that a held message was not sent until it was sent again.

  • Generate hero 3D models from text prompts

    Create product plates and optimized GLB models with Nano Banana 2 and Meshy 7.1 on fal.

    View prompt
    In the blendi-remade/dioramas repo, add a job for <object description> to assets/jobs/ following the existing job files, then run the generation and optimize scripts from the README. Expected output: a new optimized GLB in public/models/ and the generated image in the job output. Verify by confirming the GLB file size is in the 3 to 8 MB range the README gives for optimized models.

  • Split a project into parallel branch work under a Manager

    Use a Manager to coordinate several Leads, each working on its own durable Git branch.

    View prompt
    Using the pi-herdsman repo, set up a Manager that assigns <number> independent tasks from <task list file> to Leads on separate Git branches. Expected output: a list of active Leads with their branch names and assignment status. Verify that each Lead is listed under the Manager's current project assignments.

  • Run the BoardUI chat app on your machine

    Install dependencies, add your key to a local env file, and start the chat on localhost.

    View prompt
    In the repo BoardUI/boardui, install dependencies and start the dev server, then report the local URL. Expected output: a running chat page that returns a model reply to a test message. Verify that the key is in .env.local and not in any client-side file.

  • Find a past message in one WeChat chat by keyword

    Search the text of a single conversation from the command line without scrolling through WeChat.

    View prompt
    Use the greenbubbles CLI from the repo bojieli/greenbubbles to search one chat. Run `greenbubbles messages search --conversation "<chat name>" --query "<keyword>"` and report the matching messages as JSON Lines. Verify that every returned message has its chat name and local time before you summarize it.

  • Let an approved MCP agent revise an open CAD project

    Connect Codex to PartMode so the agent works on your open project after you approve it in the browser.

    View prompt
    Using the PartMode MCP server configured for this repository, call cad_capabilities, then inspect the open project at <project-name> and create a detached preview of the change <change-description>. Report the operations you proposed and the document revision they target, and verify that no commit happens until the person approves it in the browser.

  • Reproduce the one-loop box with the Landau Alphabet engine

    Run the Landau Alphabet test to reproduce the solver's reference results for a one-loop box integral.

    View prompt
    In the bootloops repository, run `python3 tools/landau-alphabet/test_landau_alphabet.py`. Report whether it reproduces the solver's reference results for the one-loop box and how long it took. Verify that the reported values match the reference values in the test, not values you computed yourself.

  • Review agent screenshots, previews and changes on your phone

    Open what an agent built, including dev-server pages and working changes, without going back to your desk.

    View prompt
    Using the BotBus app paired to <computer name>, list the artifacts and dev-server previews attached to task <task ID>. Confirm that each item opens on the phone and report anything that does not load.

  • Turn research into a slide deck outline

    Convert a research topic into a narrative slide outline with speaker notes ready for AI Slides.

    View prompt
    Using the genspark-claw repo at github.com/breakstageaxe61/genspark-claw, install the spark-slides skill and use it on these notes: <research-notes>. Expected output: a numbered slide outline with claim-shaped titles and speaker notes that cite sources. Verify that each slide carries exactly one idea and that each speaker note names a source before reporting success.

  • Try unfamiliar code in a disposable sandbox

    Open a root shell in a throwaway sandbox, then delete it when the test is done.

    View prompt
    Using the brig-sh/brig repository, run `brig run ubuntu <project path>` to open a root shell in a sandbox, then run the test command the user gives you inside it. Report the output and then run `brig rm ubuntu`. Verify that the README says `brig rm` removes the sandbox and deletes its guest home.

  • Fill fields in a desktop app that has no API

    Set field values and type text into a Mac app window using numbered elements from a read.

    View prompt
    Using the macos-harness repo at https://github.com/browser-use/macos-harness, read the window of <app name> with `macos-harness get_app_state --app <app name>` and set each field listed in <values file> with `macos-harness set_value`. Verify by reading the window again and reporting every field that does not match its expected value.

  • Lint an existing SVG and read findings as JSON

    Run svg-lint on a diagram and get each violation with its check id and repair line.

    View prompt
    In the svg-diagram repo, run node tools/svg-lint/bin/svg-lint.mjs <path/to/file.svg> --json and list each finding's check id and repair line. Confirm the file reports 0 errors and 0 warnings before calling it clean.

  • Keep a long chat's cache warm while you step away

    Send small keep-alive requests during idle time, then resume the saved handoff or the same chat on return.

    View prompt
    In Claude Code with ctx-handoff-mod installed, check the cache refresh status for <conversation> using `/handoff`. Expected output: a line reporting how many refreshes were used this idle period. Verify the status line before stepping away.

  • Turn a reference Short into a grounded production plan

    Paste a Short you like and get concepts, a tool path, and a cost estimate before generation starts.

    View prompt
    In the OpenMontage repo at <repo-path>, analyze the reference video <video-url-or-path> and produce 2-3 concepts about <topic>, each with a cost estimate at 60 seconds. Verify that each concept lists the tools available in the current environment.

  • Debug an app error from combined native and JS logs

    Read iOS, Android, and Metro logs together and send a failing stack trace to Codex.

    View prompt
    Using the callstackincubator/codex-mobile-dev-plugin Mobile Dev plugin, read the logs for the foreground app on <device name> and find the error matching <error text>. Expected output: a summary of the error with its stack trace and a proposed fix in <project path>. Verify the stack trace quoted matches the log entry before editing any file.

  • Catch quality regressions before a prompt or model change ships

    Run an eval suite on every prompt or model change and compare results to the baseline.

    View prompt
    Using the repo calmrocks/ai-engineer-notebooks, run the regression eval in 04-evals/03-regression-evals.ipynb on <placeholder prompt file> before and after a change. Expected output: a table of baseline and candidate scores per metric. Verify that the judge's agreement with human labels was checked before you trust its scores.

  • Test whether an agent breaks a rule to reach a goal

    Set up a team sandbox test and read the Observer report on who broke what.

    View prompt
    In the canivel/dynolab repo, read docs/agent-sandbox-tests.md and use the Dyno Assistant to draft a team sandbox test for the goal <goal-description>. Expected output: a setup in Agents → Setup with a lead agent, teammates and an Observer. Verify that nothing runs or saves until you approve it.

  • Pick the right face in a multi-person video

    Choose the subject per shot by eye so the tracker stays on the right person across hard cuts.

    View prompt
    Using the repo Carasibana/ComfyUI-H3-FaceRefine, set up the H3 Load Video + Face Select node for <video path> so the subject is chosen per shot. Return the list of shots and the chosen face for each, and verify that every shot has a subject assigned.

  • Code with Claude Code on a local model

    Start Claude Code connected to the Slotstream local model with one command.

    View prompt
    Using the carloslfu/slotstream repo, run `slotstream launch claude` in the project folder <project path>. Expected output: Claude Code starts connected to the local Slotstream model. Verify by asking it to summarize one file in <project path> and confirming a reply comes back without a network call to a hosted model.

  • Check whether a planned hire is affordable

    Use the finance unit-economics skill to test a hire against your revenue and cost figures.

    View prompt
    Using the cbrock84/headcount repo, load the finance:unit-economics skill and assess the hire described in <hire-figures-file>. Expected output: an affordability view based only on the figures in that file. Verify that every number cited in the answer appears in the input file.

  • Fold a RAG corpus and its queries so Chinese terms match

    Apply folding on the way into the index and on the way out, then restore verbatim matches with rerank.

    View prompt
    Using the cjkfold repo, add fold_documents to the document loading step of <path-to-pipeline-file> and fold the question before the vector search. Report which documents move up after rerank for the query <query-text>. Verify that the folded question and the folded stored text both contain the target term when checked with the in operator.

  • Normalize your own data API into point-in-time batches

    Save a data connection, map its fields, run a trial pull and check PIT status and fingerprints before research uses it.

    View prompt
    In the finathink repo, follow docs/USER_DATA_API_GUIDE.md to map the fields of <data API name> and run one explicit trial connection. Report the DataBatch fingerprint, field quality summary and PIT status. Verify that no credential value appears in any saved research record or log.

  • Score each tracked pedestrian's accident probability in a clip

    Get a per-frame probability for every tracked pedestrian in a short traffic video segment.

    View prompt
    In the JEV_sees repo at <repo path>, with TYPESAFE_API_KEY set, run examples/traffic_relations.py on assets/traffic.mp4 for frames 504 to 600. Report frame_index, object_id, and probability for each pedestrian; verify that the output describes the current frame and does not forecast future accidents.

  • Get a numbered quest route drawn on your world map

    Ask the agent for a route and follow the navigator arrow from stop to stop.

    View prompt
    In the wow-ai repo, after the bridge is running, ask the chat agent to draw a numbered route for <list of quests or zones> on the world map. Expected output: numbered stops and marks visible on the world map with a navigator arrow. Verify the route appears on the map before telling the user it is ready.

  • Let an agent read a document map first, then one section

    Give an agent a command that returns a document one level at a time, coarsest first.

    View prompt
    Using the TextFold repo at github.com/chenxiachan/textfold, run `python3 -m textfold get <document> ` first without a level to read the section map, then run it again with `--level key --section <n>` for the one section that answers the task. Expected output: the section topics, then the points of that section with their reasons. Verify that each model-written line is marked as such before using it.

  • Let an AI agent browse a logged-in profile

    Connect Claude Code to FoxProfile over MCP so the agent can open pages, click and take screenshots.

    View prompt
    Using the repo chienbm98/foxprofile through its MCP server at http://127.0.0.1:8000/mcp, launch the profile <profile-name>, navigate to <target-url>, and take a screenshot. Return the screenshot and a one-line summary of the page title. Verify that the profile appears as running in running_profiles before you navigate.

  • Cut Claude Code session size in Claude Desktop by leaving out past images

    Install the plugin from the command line, start a new Code tab session, and uncheck old images to shrink each request.

    View prompt
    Using the repo chipfighter/context-attachment-manager, add the marketplace and install the plugin for Claude Code, then start a new session in Claude Desktop's Code tab for the project <project folder>. Uncheck the images from earlier turns in the panel and confirm that the savings card shows a smaller estimated request than before.

  • Continue Harness sessions from an iPhone on Wi-Fi

    Pair DSH Remote with your computer on trusted Wi-Fi to check projects, steer tasks, and handle approvals.

    View prompt
    Using the chokwinlee/deepseek-harness-desktop repo, walk me through pairing DSH Remote on an iPhone running iOS 17 or later with DSH Desktop on my computer over my trusted home Wi-Fi. Expected output: a paired phone that lists my projects and running sessions. Verify that the phone and computer are on the same trusted network before you start pairing.

  • Clone a character voice from recordings you have rights to

    Turn your own recording into reference clips, upload them and measure how close the voice sounds.

    View prompt
    In the NPCTalk repo at https://github.com/christos-antono/NPCTalk, use the voice-references and voice-likeness-eval skills to build a voice from <recording-path> that you have rights to. Expected output: a voices/<name> folder uploaded to the server and a WAV from `npctalk say`. Verify with `npctalk check` that no audio, transcripts or keys are staged for commit.

  • Vet a seller before buying

    Run NorthCinder's seller research guide to check identity, sources, and unknowns.

    View prompt
    Using the NorthCinder MCP server, read northcinder://research/seller, then call create_research_plan for the seller <seller name> and the request <request>. Return the checklist results, source conflicts, and unknown seller history, and mark the result as provisional. Verify that the seller identity matches the exact merchant named before treating any finding as usable.

  • Rebuild agent state by replaying an event log

    Keep an agent's history as an immutable log and derive its state from it.

    View prompt
    In the repo clavia-labs/tardigrade, add a durableAtom named <atom-name> that uses reduceTrajectory and the Event input, then derive a messages atom from it. Expected output: a TypeScript module that exports the durable history and messages atoms. Verify that the initial value matches the TrajectoryState schema.

  • Label DataFrame rows with closed-set Jev answers

    Ask Jev a closed-set question for each row, cache the answers, and join them back to the table.

    View prompt
    Using the steven-shoemaker/hunch Python library, classify each row of <dataset path> into the closed-set labels <label list>. Return the labeled table and a count per label. Verify twenty random rows by hand before reporting results.

  • Point Claude Code at your PS5 model

    Route Claude Code requests to the PS5 model server through its Anthropic-compatible endpoint.

    View prompt
    Using the cobanov/PS5LM repo, configure Claude Code to use the PS5 at <PS5-IP> on port 8081 as its Anthropic endpoint. Expected output is a reply from the loaded model, and verify that the request appears in the chat on the TV.

  • Design a custom workflow with fail and rollback paths

    Edit the FSM canvas to add nodes, guards, and fail or rollback edges.

    View prompt
    Using the Grasp repo (cocofhu/grasp), create a workflow in <Grasp workspace> on the FSM canvas that adds a rollback edge from the test node to the implement node. Verify the rollback edge is saved and report the node list and edge list.

  • Find every existing rule violation in a codebase at once

    Judge current files as if they had just been written and get a report by rule and by file.

    View prompt
    In the repo <repo-path>, run `abide audit src/` and save the output. Then list the three rules with the most violations and the three files with the most violations, and report the total cost the README-style audit printed.

  • Confirm the ablation hooks fire before evaluating

    Run the self-check to confirm 129 residual writers are wrapped and the refusal component drops.

    View prompt
    In the repo Continuum-AI-Corp/OrcaBonsai-27B-Uncensored, run python scripts/selfcheck.py with --pack set to <pack-path>. Expected output: 129 residual writers detected and a remaining refusal-direction component near 1e-6 of the residual norm. Verify both numbers before reporting success.

  • Fork a run at one step and compare models

    Keep the first steps of a recorded run fixed, switch to another model from a chosen checkpoint, and compare results.

    View prompt
    Use the OrcaReplay repo (Continuum-AI-Corp/OrcaReplay) to fork the recorded run `last` at checkpoint 4 onto the models <model-a> and <model-b> using `orca compare last --from 4 --models <model-a>,<model-b>`. Report one comparison table with the outcome for each model. Verify that turns before checkpoint 4 are identical across both forks.

  • Embed reusable agents in your own application

    Install the Harness library from source and start its quickstart.

    View prompt
    In the agent-foundation repo, clone it, run `uv sync --locked --package a13n-harness`, and report the sync result. Then list the runnable examples in examples/README.md that use the Harness package and name one that fits <your-application-type>.

  • Gate a Bot's browser actions with deny rules

    Add a deny rule in the boundaries admin page, retry a browser action, then read the audit log.

    View prompt
    In the OpenBot repository at <repo-path>, start the stack per README.md, add a deny rule at /admin/boundaries that blocks browser navigation, then retry the news.ycombinator.com request from /bot. Report whether the action was blocked and quote the matching entry from /admin/audit.

  • Rewrite sections of a Word document with AI, using your own key

    Ask an AI agent to edit a .docx block by block, then review the diffs and snapshots before keeping them.

    View prompt
    Using the HermesOffice repo at github.com/criptogus/HermesOffice, ask the document agent in HermesOffice Docs to revise <section name> of <path to .docx> to <desired change>. Output the revised .docx and the list of block-level diffs. Verify that paragraphs outside the requested section are unchanged.

  • Give each coding task its own Git worktree and branch

    Run parallel agent tasks in separate worktrees so their changes never collide.

    View prompt
    In the diri repo at github.com/cristicretu/diri, confirm that each agent session for <task-list> has its own Git worktree and branch. Output a table of session, worktree path, and branch name, and verify that no two sessions share a branch.

  • Build a wiki that runs on your own computer with Ollama

    Use a free local model through Ollama so documents and answers stay on your machine.

    View prompt
    Set up the llm-wiki-v2 repo with Ollama as the provider and gemma4 as the model, then file <document> and ask <question>. Expected output: a cited answer. Verify that the model call went to the local Ollama server, not a remote provider.

  • Plan a change read-only before any file is edited

    Run plan mode so the agent researches without writing and waits for your approval.

    View prompt
    Using the cryer/star-cli repo, set permissionMode to plan in ~/.star-cli/config.toml, run `star` in <project-dir> with the request <task>, and report the plan it produces. Verify that no files changed before approval by checking `git status`.

  • Ask WhatsApp about your Gmail and Calendar

    Text the bot in plain English to find emails or check your calendar, using your own Google account.

    View prompt
    In the csr1010/wappy-kit repo, scaffold a project with `npm create @wappy_ai/agent` into ./<project-dir> and choose the productivity agent. Expected output: a project that includes the Gmail/Calendar tools and a local Google connect page. Verify that the generated tools are read-only and that no send or delete function was added.

  • Fill a long web form in one call and submit it

    An agent sets every field of a multi-step web form and clicks submit, with typed errors on failure.

    View prompt
    Using the axuse MCP server, open <form URL> and fill the form with these values: <values as JSON>. Use one fill action, then read the accessibility snapshot to confirm each field holds the intended value before submitting. Report any field that returns an error code.

  • Split a large task across parallel cloud agents

    Use the orchestrate plugin to run planners, workers, and verifiers on one big job at once.

    View prompt
    Using the orchestrate plugin from the cursor/plugins repo, split the task <task-description> into parallel sub-tasks with a planner, workers, and a verifier. Output the plan, the worker assignments, and the verified handoffs. Verify that every sub-task has a verifier result before you report it as done.

  • Record every tool call of a Python agent run

    Add two lines to a Python agent so each tool and model call is gated, signed, and checked after the run.

    View prompt
    In the project at <project-path>, install tracekit-ai with `pip install tracekit-ai`, add `import tracekit; tracekit.instrument()` as the first line of <agent-file>, run the agent, then run `tracekit last`. Expect output containing 'Integrity: VERIFIED.' and an Assurance line. Verify that the Assurance line says dev, since this is a dev signer.

  • Run a high-stakes change in full mode with extra checks

    Use the skill's full mode for risky or hard-to-reverse work with more verification.

    View prompt
    Using the Da7-Tech/SureForge skill in full mode, plan and carry out <change description> in <repository path>. Expected output: a gate result for each phase, the tier used, and a coverage ledger listing what was verified and what was not. Verify that the agent states plainly if no independent reviewer was available.

  • Pick the next window for a task by token use and quota

    See what each AI window spent and which window or model should take the next task.

    View prompt
    Using the Squadra repo at https://github.com/dagoSte/squadra, rank the AI windows in the squad at <project path> for task <task ID>. Expected output: the output of `squadra balance --task` with the figures each suggestion rests on. Verify that the ranking lists every registered window and that no window is assigned automatically.

  • Run a Codex candidate on one Terminal-Bench task

    Score a candidate agent on a single Terminal-Bench 2.0 task and read the per-task result.

    View prompt
    In the rsi_eval repo, set target.model and the Codex login directory in examples/evaluate.json for <model-name>, then run `rsi-eval run --config examples/evaluate.json --output runs/<new-output-dir>`. Report status and per-task reward from result.json. Verify that the output directory did not exist before the run.

  • Build a font from a photo with the CLI, no AI

    Run one npx command on a freeform photo and get a font file you can install.

    View prompt
    Use the draw-your-font CLI from the danilo-znamerovszkij/draw-your-font repo to build a font from <photo-path> with --chars set to <characters-in-order> and --name set to <font-name>. Expected output is a .ttf file in the working directory. Verify the file exists and that the preview command renders the sample text.

  • Run an existing verl config on one GPU

    Point miniVERL at a verl config tree, switch to GRPO and check the run with a dry run.

    View prompt
    Use the miniverl repo (DaoyuanLi2816/mini-verl) to dry-run a verl config at <verl-config-path> with the ppo_trainer config name and GRPO overrides. Report whether the dry run succeeds and list any overrides that failed. Verify that no training starts during the dry run.

  • Get OCR lines and boxes as JSON for a data pipeline

    Extract each line with its box, confidence, and layout label as JSON.

    View prompt
    Using the repo datalab-to/indra, install indra-ocr and run `indra-ocr <input-file> --format json` on <input-file>. Expected output: JSON with lines (box, text, confidence) and blocks (label, bbox, text) per page. Verify that the block labels in the output match the labels listed in the README, such as Text, Table, and Form.

  • Chat with the published EBFM SFT model in a browser

    Serve the EBFM-FineWeb-1B-CHAT model through a local web chat interface.

    View prompt
    In the datamllab/OpenEBFM repo, start the web chat with runs/chat.sh using guan-wang/EBFM-FineWeb-1B-CHAT on host 0.0.0.0 and port <port>. Report the URL to open and confirm the server responds on that port.

  • Build a mini inference engine step by step

    Follow Part II to add forward pass, KV Cache, HTTP serving, paging, and RadixAttention to a mini-sglang.

    View prompt
    Use the repo https://github.com/datawhalechina/zero-to-sglang and implement Chapter 4 (KV Cache) of Part II in <target-directory>. Expected output: a generation loop that reuses cached keys and values for a short prompt. Verify that the output tokens match a run without the cache for the same prompt.

  • Build and test the Cloudroom core from source

    Compile the Rust service in release mode and run its full test suite before you deploy it.

    View prompt
    In the cloudroom-core repo at <clone-path>, run `cargo build --locked --release` and then `cargo test --locked --all-targets`. Expected output: a release binary and a summary of passing tests. Verify that the test run reports zero failures before reporting success.

  • Try several fixes at once in isolated cloud branches

    Run separate cloud agent threads, each in its own sandbox and Git branch, and compare results.

    View prompt
    In the cloudroom-gui repo's Cloudroom app, start two Cloud threads for <repository and task>, each with a different approach. Expected output: two separate Git branches, one per thread. Verify that each branch has its own sandbox changes before choosing one.

  • Check dashboard YAML for errors before merging

    Run strict validation on board files in a pull request, with no warehouse needed.

    View prompt
    In the dbt-charts repo, run `dct validate --strict` on the boards changed in <placeholder> and list every error and warning with its file path. Verify that the command exits cleanly once the issues are fixed.

  • Hold high-value API calls until a person approves them

    Route consequential HTTP requests through a gateway that holds the risky ones for approval.

    View prompt
    Using the decionis/agent-safe-pipeline repository, install AgentSafe and start `agentsafe proxy --upstream <your-api-url> --port 8080`. Send one POST request to /payments through the gateway with an amount above the approval threshold, and report the decision and the HTTP status. Verify that the upstream received no request for that call.

  • Run a private FDE Gym site for your team's engineers

    Host the judge for your own people, with an admin console for cases and members.

    View prompt
    In the fde-gym repository at <path>, read docs/self-hosting.md and list the settings a team needs to change before sharing the site. Output the list as bullet points with the setting name and what it controls. Verify each item appears in that document before listing it.

  • Add agent status and chat components to an AI app

    Install Solid Glass's agent-focused components for status, steps, diffs and questions.

    View prompt
    In the React project at <project-path>, install the Solid Glass components `turn-status`, `composer`, `tool-steps` and `ask-card` from the deeplethe/solid-glass registry with `npx shadcn@latest add deeplethe/solid-glass/<component>`. Report which files were created and confirm the project still builds.

  • Show who held a role in a past quarter and what was known then

    Ingest dated announcements and minutes, then ask who held a role in a period and what the base believed at the time.

    View prompt
    Using the Utopia repo at <repo path>, load the dated records in <folder> and ask who led <project> in <quarter> and what the base believed about it then. Expected output: the holder for that period and the separate belief-at-the-time answer, each with its source. Verify that any correction shows the entry it replaced.

  • Build and run the harness from a git checkout

    Clone the repository, install dependencies, build the artifacts, and start the Web UI from source.

    View prompt
    Clone https://github.com/deepseek-ai/deepseek-harness into <target folder>, run `pnpm install` and `pnpm run build`, then `pnpm dsh web`. Report whether the build finished without errors and the URL the Web UI is served on.

  • Run a workflow in CI and parse its JSON event stream

    Execute a saved workflow in a build pipeline and read a stable JSONL event stream.

    View prompt
    Using the deer-workflow repository (deerwork-ai/deer-workflow), add a CI step that runs ./workflow.ts with the input <target input JSON> and the --print flag. Expected output: a captured JSONL event stream saved as an artifact. Verify that every stdout line parses as JSON before the job reports success.

  • Run the Human Agency example to see reserved actions

    Run the minimal Human Agency Profile script to see which agent actions are allowed and which need a human.

    View prompt
    Clone https://github.com/dengyier/OpenWorkProof, create a virtual environment, install it in editable mode, and run `python examples/human_agency_profile_v01.py`. Report whether the output shows 'profile verified : True' and that owp.apply_patch returns AGENCY_HUMAN_DECISION_REQUIRED. Verify that the script writes no application files or ledgers, as the README states.

  • Generate a new picture from boxes and reference images

    Draw boxes on an empty canvas, describe each one, and have FLUX 3 Image build the scene.

    View prompt
    Using the Scumble repo at https://github.com/DenRakEiw/scumble, create a new image on an empty canvas with boxes described as <list of box descriptions> using FLUX 3 Image with my Black Forest Labs key. Expected output: a generated picture returned as a layer. Verify that each boxed area reflects its description.

  • Scan a whole package for review risks

    Run a complete codebase scan on a repository or package and browse the results in the dashboard.

    View prompt
    In the jev-review repo, run `npm run review:codebase:save -- <path to package>` and then `npm run dashboard`. Produce a short list of the top five areas flagged, each with its file and the reason given. Verify one area by opening the cited file and confirm the flagged code is actually present.

  • Spread a Claude Code session's subagents across accounts

    Run the main agent and each subagent on different pooled accounts to share the load.

    View prompt
    Using the DevDock-AI/claude-unlimited repo, start a session with `cu code --distribute` in <project-path> after at least two accounts are in the pool. Expected output: subagents are spread across accounts as shown on the dashboard. Verify that the dashboard lists more than one account in use during the run.

  • Review agent changes per file and open a PR

    Check each diff the agent made, then commit, push, and open a PR or MR from the browser.

    View prompt
    Using the agentbox repo at github.com/devilcoolyue/agentbox, run a workspace on <server-host> against the repository <repo-url>. Ask the agent to make the change <task>, then list every changed file and its diff summary before any commit. Verify that nothing is pushed until the diffs are approved.

  • Check how a profile scores on fingerprint test sites

    Open a profile on the public test pages the project uses to check its own kernel.

    View prompt
    Using the repo DFarm6/Prism-Browser-Community, summarize which fingerprint tests the kernel is checked against for <target profile name>. Expected output: a table of test site and coverage. Verify the README note that scores change over time before reporting a result.

  • Inspect a labeled skill ranking offline first

    Run the built-in fixture demo and readiness checks before sharing any real session.

    View prompt
    Using the Dicklesworthstone/skillranker repo, run `sr demo --case useful` and `sr rank --context <context file> --dry-run`. Expected output: a labeled fixture result and a redacted request preview with no network call. Verify that the preview contains no API key or secret values before sharing it further.

  • Send one API call to many models from a script

    Point any OpenAI-style client at one local endpoint and switch models without changing code.

    View prompt
    Using the diegosouzapw/OmniRoute repo, write a script that sends the prompt <prompt> to http://localhost:20128/v1/chat/completions with model auto and prints the reply. Run it and report the reply text. Verify that the HTTP status is 200 and the reply is non-empty.

  • Sync a provider's models and set context limits

    Refresh the model list after a provider changes its models and set the default and context length for each.

    View prompt
    Using the uni-switch project at github.com/dieqiyun/uni-switch, sync the model list for the provider <provider-name> and report which models were removed and which default model was chosen. Expected output: a list of enabled models and the new default. Verify that the default model is still present in the synced list.

  • Preview every dashboard view with no GPU or model

    Run the built-in demo to see all views on synthetic data before setting up a real server.

    View prompt
    Using the repo DingoOz/llm-visuals, run `cargo run --release -- --demo` in a terminal of at least 140 by 44 characters. Expected output: a dashboard showing a synthetic server and two synthetic GPUs. Verify that pressing `q` restores the terminal cleanly.

  • Watch a proactive agent open an incident

    Run the demo where an agent starts on its own, investigates a failing checkout and waits for your deploy approval.

    View prompt
    In the Durable Pi repo at <repo path>, run `just proactive take` and capture the printed URL. Report the URL and whether the agent asked to deploy within about 30 seconds. Verify that the deploy task is waiting for approval and has not run.

  • Keep AI coding sessions running through SSH drops

    Start Claude Code or Codex on a remote host and reconnect later without losing the session.

    View prompt
    On the remote host <host>, install Session Kit from https://github.com/dob323/session-kit using the latest release artifact, run `session-kit services enable`, then start a session with `sp new claude`. Verify with `kit` that the session is listed and still running after the SSH connection is closed and reopened.

  • Collect data from web pages using a browser agent

    Have DomA browse a set of pages and gather the information you need into one place.

    View prompt
    Use the dom-actions/doma repo as a browser agent to visit the pages listed in <URL list file> and collect the fields <field names>. Expected output: a table with one row per page and one column per field. Verify by opening three random pages and comparing their values with the table.

  • Keep notes and facts across DSH coding sessions

    Add a memory plugin so DSH re-reads global and per-project markdown notes in later sessions.

    View prompt
    Using the DSH list at https://github.com/Dominic789654/awesome-deepseek-harness, install the dsh-memory plugin from github.com/jipika/dsh-memory into the web profile. Ask the agent in a new session to state the convention written in <project-note-file>. Expected output is that convention stated back correctly; verify it matches the note text.

  • Run a multi-step web workflow in one agent call

    Batch browser actions and branch on page state without a round trip per step.

    View prompt
    Use the bladebro MCP server to complete the workflow described in <workflow description> on <site URL> using act batch or run. Return the final page state and the list of actions taken. Verify the outcome verdict for each step before reporting success.

  • Read only the needed part of long web pages

    Use DonSeTch's token controls so an agent pulls a table of contents or one section, not the whole page.

    View prompt
    Using the donsetch MCP server, fetch the table of contents of <URL>, then fetch only the section about <topic>. Return the section text and confirm the response is shorter than the full page.

  • Answer website chat and messaging apps from one assistant

    Serve web chat, WhatsApp, Telegram, email and SMS from a single AI assistant with notifications for staff.

    View prompt
    Using the Dpro-at/Tel-Agent repo, set up the messaging channels listed in the README for <channel names> with customer-owned credentials. Expected output: a test message on each channel that gets an AI reply and shows in the conversation archive and notification tray. Verify that each channel credential is stored and that the dashboard API docs load at http://localhost:38472/docs.

  • Test a web app flow in a live Firefox session

    Have AlphaCode walk through a login or form flow in Firefox and report reproducible problems.

    View prompt
    Use the dragonked2/alphacode repo with its Firefox browser automation to test the login flow at <application URL>. Report each step, capture a screenshot of any failure, and list only problems you could reproduce. Verify the report by repeating one failing step manually.

  • Draft a standup from what you actually did

    Turn the day's written record into a standup update grounded in what was on screen.

    View prompt
    In the dragthelake/ambient-context repo, use the standup skill to draft a standup for <placeholder date> from the Summaries file for that day. Expected output: three short sections titled Yesterday, Today and Blockers. Verify that each item traces to a block in Days/<placeholder date>/ before it is spoken.

  • Serve a Delta-rule model with compressed recurrent state

    Run a Delta-rule model under SGLang with STEP Quant state compression to cut per-request state memory.

    View prompt
    Using the STEPQuant repo at <repo_path>, calibrate a stepquant6 plan for the model at <model_path> and start the SGLang server with --state-format stepquant6. Report the server URL and the text of one test completion, and verify the server log shows the stepquant6 state format was loaded.

  • Generate and run a new themed AI story

    Turn one theme into a cast of AI characters and watch their story unfold step by step.

    View prompt
    In the repo https://github.com/dreamscroll-lab/asamana, use a configured <vendor> API key to start the app and create a world from the theme <theme>. Run 3 steps and report the number of characters and the first three narrative lines. Verify that the run stops after the step count you set and does not run indefinitely.

  • Trace permission-aware retrieval in an AI feature

    Follow one AI query from identity through authorized retrieval and grounding to the response.

    View prompt
    Read the enterprise-system-design repository and trace a retrieval request for <target AI feature> from user identity through authorization, retrieval, grounding, and response. Output a table of each boundary with its authority check and one unverified assumption. Verify that every boundary has a named owner.

  • Hand a coding task to a built-in coding agent

    Use Wu's agent workspace with Claude Code or Codex to draft changes inside your project.

    View prompt
    In the dstrml/wu repo context, open <project-path> in Wu and use the built-in Claude Code or Codex agent to make this change: <task>. Expected output: a proposed edit to <file-path>. Verify by reading every changed line before saving.

  • Block agent changes that fail an independent review

    Send each agent's finished work to a separate reviewer agent before it is delivered.

    View prompt
    In the dualface/kander repo, read docs/review-disposition.md and then review the task card <TASK-ID> on the board. Report whether the review stage found must-fix issues and whether the completion gate passed. Verify that the reviewer result is recorded on the card before you call the task done.

  • Step through a live process with an AI assistant

    Set breakpoints, step through code, and read registers and memory by describing the goal in plain language.

    View prompt
    Using the x64dbg-MCP-Server tools at http://localhost:9094/ with my Bearer token, load <target executable path>, set a breakpoint at <address or symbol>, run, and call WaitForPause. Then report GetAllRegisters and GetCallStack output. Verify that the reported instruction pointer matches the breakpoint address.

  • Locate the tests that cover a specific behavior

    Ask which tests exercise a behavior so an agent can run or extend the right suite.

    View prompt
    In the repository at <target path>, run `jg` with the question "Which tests cover <behavior>?" and list each returned test file with its line references. Verify that each listed file exists and contains the test before you run the suite.

  • Check a generated part for manufacturing problems

    Run design for manufacturing checks on a model before you send it to fabrication.

    View prompt
    Using the text-to-cad plugin from https://github.com/earthtojake/text-to-cad, run design for manufacturing checks on <model file path> and list every issue with its location. Return the report and confirm whether a second check passes after fixes.

  • Build a narrated comic with Taiwanese Mandarin voice

    Turn a brief into a narrated comic video with Yating Taiwanese Mandarin narration.

    View prompt
    In the reelmimic repo, confirm YATING_KEY is set in the secrets file and run `cd app && npm run doctor`. Then submit a narrated comic brief for <topic> with <reference video path>, approve the plan, and wait for the final review. Expected output: a narrated comic video in the project folder. Verify the narration audio plays in the final file before reporting success.

  • Steer an agent mid-task with queued follow-ups

    Send follow-up instructions while an agent is still working, without starting over.

    View prompt
    Using the waku app at <Waku install location>, start a session on the project at <project path> with the task <task description>, then send one follow-up message while the agent is running. Expected output: a transcript showing the queued or steered message inside the same session. Verify that the session ID did not change.

  • Rig a character in Rigify and export a Unity walk cycle

    Rig a character with Rigify, add a walk animation and export the result to Unity.

    View prompt
    Using the blender-skills repo, rig <character model> with Rigify, add a looping walk cycle and export it for Unity. Expect a rigged .blend or exported file and the name of the walk action. Verify that the walk action loops and that the exported skeleton keeps the rig's bone names.

  • Cap LLM spend per team, project or key

    Set dollar or token budgets and get alerts before a budget runs out.

    View prompt
    Using the eliasbiondo/antirion README, create one gateway key per project and set a dollar budget on each key in the console. Expected output: a list of keys with their budgets. Verify that a test request from one key shows its cost in the cost ledger.

  • Mirror the whole bot directory into your own catalog

    Pull the canonical raw feed once and store every listing in your own system.

    View prompt
    Fetch https://botdirectory.ai/api/bots.json, save it as bots-<date>.json, and report the total number of listings and the names of up to 5 listings that are new since the last saved file. Verify that the count in the saved file matches the number of entries parsed.

  • Host a shared bot team on a VPS with HTTPS

    Keep bots running on a server and connect from desktop, mobile, or browser clients.

    View prompt
    In the Rakazo repo at https://github.com/elie222/rakazo, follow the Run on a server section and docs/self-host.md to prepare a VPS for <your-domain>. Report the sandbox provider chosen and the public https:// address. Verify that the health check for the instance succeeds over HTTPS before reporting completion.

  • Run one robot task headlessly and get JSON back

    Send one natural-language task to a running Controller and read the JSON result from stdout.

    View prompt
    In the EMERGE-Policy repo, with the Controller already running, execute `python -m Emerge.cli.headless "<task>"` and capture stdout. Expected output is a JSON result for the task. Verify that the output parses as valid JSON before reporting it.

  • Run the AIKON test suite before changing the code

    Run the server and phone app checks so you have a clean baseline before you edit either part.

    View prompt
    In the AIKON repository, run `make test` and report the result for the server and for the app separately. Expected output is a pass or fail summary for each part, with the first failing line quoted if any. Verify that the app build downloaded its tools into app/.deps and not into the system.

  • Run a multi-harness agent team on a code review

    Start a team template so a lead harness coordinates named member harnesses on one goal.

    View prompt
    Using the repo emo-xiaoyu/harness-mix, start the built-in 代码评审 agent team template for the project at <project path> with the goal <review goal>. Report each member harness, its assigned role, and the task state, and confirm that every member is using its own native session.

  • Collect B-rolls for a Reel through Claude Code chat

    Describe the inserts in chat, approve previews on the storyboard and receive cuts in entrega/.

    View prompt
    Using the get-brolls repo as a Claude Code plugin, collect supporting B-rolls for my Reel about <topic> in project folder <project folder>. Show me the shortlist first and do not download anything until I approve the previews. Expected output: clips in entrega/ with an ORIGEM.md for each beat. Verify that each beat has its source file listed.

  • Build a code-hosting app on Enroute with a coding agent

    Give a coding agent the Enroute skills and have it build a small code-viewing app chapter by chapter.

    View prompt
    Run `npx skills add enroute-sh/enroute` in <project-dir>, then follow docs/build/README.md from the enroute-sh/enroute repository to build a code-hosting app. Expected output: a local app that shows code and diffs from a repository pushed to http://127.0.0.1:8080. Verify by pushing a test branch and confirming it appears in the app.

  • Find the commands an agent kept retrying and failing

    Use the Errors tab to see which failing command ran most often in a row and jump to it in the replay.

    View prompt
    Using the agentplay repo at https://github.com/Entelligence-AI/agentplay, run `uvx agentplay` and open the session <session name or id>. Open the Errors tab, list the top three error classes with their longest repeated failing command, and state the step where each run began. Verify that each count matches the error rows shown in the Errors tab.

  • Share one native build across agents on JS-only branches

    Cache native builds by fingerprint so many agents reuse one build and environment switches skip native rebuilds.

    View prompt
    Using the simfleet repo (entropyconquers/simfleet), set up the Expo build cache in <path-to-app> and run `simfleet native plan` to inspect the fingerprint. Expected output: a plan that lists the native inputs and whether a cached build exists. Verify that changing only a JavaScript file leaves the native fingerprint unchanged.

  • Render the full promo video with zones, depth and soundtrack

    Rebuild the demo pipeline: extraction, zones, depth, render and synthesized audio.

    View prompt
    Using the repo escudero/brandpose, follow docs/experiments/2026-10-14-promo-v2.md to run the promo pipeline in scripts/promo/ on the ACTi demo video. Report the output video path and the stage that failed, if any. Verify that the zone ranking in the rendered report matches the zones in config/zones_acti.json.

  • Have Opus plan and a native worker build, then review

    Split one assignment so Opus plans and reviews while a configured worker implements it.

    View prompt
    Use the codex-on-crack package in <project folder> to have Opus plan <feature name> and a configured native worker implement it, then return the result to Codex for review. Expected output: a plan, the worker's changes, and a review note from the lead. Verify that the review cites the worker results and host-tool evidence.

  • Find benchmarks for evaluating LLM agents on games

    Locate benchmark papers such as Orak and VideoGameBench to compare agent evaluations.

    View prompt
    Using the Eurekaleo/awesome-ai-for-games README, list every benchmark paper in the Play and Act section that evaluates LLM or VLM agents on video games. For each one, give the title and paper link, and state whether the README links code for it.

  • Install the Skill Corpus plugin in your agent host

    Let your agent install the Skill Corpus plugin for OpenClaw, Hermes, Raven, WorkBuddy, or DeepSeek Harness.

    View prompt
    Read https://github.com/EverMind-AI/SkillCorpus/blob/main/skillcorpus_plugin/INSTALL.agent.md and install the SkillCorpus plugin for <host name>. Report which mode you configured (on demand or auto) and the path of the shared skills directory. Verify that a test query returns at least one skill.

  • Summarize graded trials by task and in total

    Turn a folder of graded Harbor trials into per-task and JSON score summaries.

    View prompt
    In the facebookresearch/swe-sweep repo, run `sweep info <path-to-graded-trials> --json` and save the output. Verify that the reported total equals the number of bugs solved across tasks divided by the total number of bugs.

  • Compare two agent runs event by event

    Load two sessions and see recorded metric differences and aligned tool calls.

    View prompt
    Using the TraceCrate repo at <repo path>, start the dev server and load the two authorized session files <baseline file> and <changed file>. Expected output: the Compare view with recorded metric differences shown as B minus A and an event-by-event list. Verify that the comparison is described as descriptive, since repeated tool names can align ambiguously and this is not a controlled benchmark.

  • Chat with Kimi K3 offline and save the transcript

    Run multi-turn chat with the official XTML format on your own CPU, saved to a JSONL file.

    View prompt
    In the repo FareedKhan-dev/kimi-k3-in-c, start the --chat REPL with --history <history_file> and --incremental. Send one user message and expect an assistant reply. Verify that the history file contains a user record and an assistant record in JSONL form.

  • Chat with a coding agent in native phone chat

    Use a phone-native chat interface for Codex, Claude Code or another supported CLI on a remote host.

    View prompt
    Using the farlume/termish README, list the setup needed to use the Agents entry with <agent name> on host <host>. Expected output: a short list of prerequisites and the steps to start a chat. Verify that the list states that the remote host needs the agent's own login or a supported API provider configuration.

  • Turn a Claude Code session into a narrated recap

    Render a 30 to 60 second film of what your agent did in its latest session.

    View prompt
    Using the showtime skill in the FavioVazquez/showtime repository, run `showtime recap --latest` to make a 30 to 60 second narrated recap of the most recent Claude Code session. Expect a rendered film in a new showtime-out/ folder. Verify that the narration uses only the allow-listed facts and does not quote the transcript text.

  • Use small robot avatars in a chat or user list

    Drop a compact robot head into list rows using the antenna-free small size option.

    View prompt
    In the React project at <project path>, install robot-heads and render a list of agent avatars using RobotHead with antenna={false} and a small size. Expected output: a list component where each avatar keeps its state and has an aria-label. Verify that no parent element in the list uses overflow: hidden around the avatar.

  • Run the desktop app locally for a study group

    Clone the repo and run the Tauri desktop app so a group can use every feature, including the local AI guide.

    View prompt
    Clone https://github.com/Fazmin/AILearningGuide into a <target-folder>, run npm install and then npm run tauri dev. Expected output: the Discover AI desktop window opens with the home screen. Verify the home screen shows the six groups of labs.

  • Run a web browsing agent in a local chat window

    Start the standalone web UI with your OpenRouter key and type a browsing task on the left, watch the browser on the right.

    View prompt
    Using the invisible-playwright-mcp web UI from feder-cr/invisible_playwright_mcp, send this task to the agent: <task describing the page and the information wanted at <target-url>>. Expected output: the agent's answer in the chat, with the browser showing the page it read. Verify that the answer names the source page and does not guess any value the page did not show.

  • Rebuild a feature demo from screenshots, no recording

    Turn a set of app screenshots into a feature demo where the interface is rebuilt in HTML and the camera flies into it.

    View prompt
    Using the onetake skill in the feitangyuan/onetake repo, build a feature demo of <feature name> from the screenshots in <screenshot folder>, with no screen recording. Output a video file of the demo. Verify that the rebuilt interface matches the screenshots and that the camera moves between the steps without cuts.

  • Answer contract questions with cited passages

    Index a folder of contracts and let an agent pull the clauses it needs before it answers.

    View prompt
    Use the Carrel search API in the FengZhenfei/carrel repo at http://127.0.0.1:9810/search to find the clauses about <contract term> across the enabled contract folder. Report each answer with the source passage it came from. Verify that every claim in the answer appears in a returned passage.

  • Measure what screened companies did between filings

    Run a screen over a date window and read each passing company's return between its own filing dates.

    View prompt
    Using the Qanat project at <project-folder>, run a windowed screen from <start-date> to <end-date> on the metric and threshold <rule>. Report the per-company return from each company's own filing to its next filing, along with the evaluated and unevaluated counts. Verify that no average or aggregate has been added, since Qanat reports per-company returns only.

  • Have Claude build queued issues into pull requests

    Run a builder loop that claims the next safe agent-ready issue, implements only its contract, and opens a PR.

    View prompt
    In the GitHub repo at <repo path>, run /loop /finn-build against the Linear team <team key>. Expected output: a PR linked to the claimed issue. Verify that the PR changes only what that issue's acceptance criteria require and respects its non-goals.

  • Switch to the expanded workflow and archive many changes at once

    Enable the full set of Open Spec commands and clear finished changes in one pass.

    View prompt
    In the Fission-AI/OpenSpec project at <project-path>, select the expanded workflow with `openspec config profile`, then run `openspec update`. Expected output: the new commands such as /opsx:verify and /opsx:bulk-archive are listed as active for your assistant. Verify that openspec/changes/ lists the finished changes before running /opsx:bulk-archive.

  • Find an earlier decision in past Pi sessions

    Search prior conversation and sub-agent runs in the project to recover a decision or error detail.

    View prompt
    Using the pi-posthorse repo (fitchmultz/pi-posthorse), use the history tool in the project at <project-path> to search earlier sessions for the decision about <topic>, including other sessions with all: true. Expected output: the matching history entries with their session context. Verify that each quoted detail appears in the returned history entries before you rely on it.

  • Save a Python sensor run to a .dlr file for later review

    Log data from a script to a .dlr file and open it in the viewer afterward.

    View prompt
    In the Flaminis/Dalaran repository, install dalaran-sdk with pip, then write a Python script that logs 100 frames of a point cloud to session.dlr using dl.save. Expected output is a session.dlr file. Verify it by running dalaran session.dlr and confirming the frame timeline appears.

  • Let an AI coding agent find and add UI items for you

    Connect the affectUI MCP server so Claude Code, Cursor or Codex can search items and install them.

    View prompt
    Use the affectUI MCP server at https://www.affectui.com/api/mcp to search for <component-need> and add the best match to the <project-path> React 19 project. Expected output: the new component file in components/ui and a short note naming the item chosen. Verify that the project builds after the file is added.

  • Search every past agent session for an earlier decision

    Use regex and ranked search to recover how a problem was solved in a previous session.

    View prompt
    Use the flopwire/flopwire CLI to search all indexed sessions for <topic> with `flopwire search '<topic>'`. Report the top three hits with user, device, harness, and session for each, and confirm each hit by reading its passage with `flopwire read`.

  • Hand off a Claude session to Codex through the CLI

    Extract a Capsule from a Claude session file and write a Codex handoff file with the handoff command.

    View prompt
    Using the Frankie-Xu/threadport repo after `npm ci` and `npm run build`, extract a Capsule from <session-file> with --from claude and --project <project-directory>, then create a Codex handoff at <handoff-path>. Report both printed output paths and confirm that `node dist/src/cli.js validate --handoff <handoff-path>` succeeds.

  • Test motion and looming output from a webcam or video

    Feed a webcam or your own video into the mock backend in dry-run mode to inspect vision signals.

    View prompt
    In the flybrain-robot-bridge repo, run python -m flybrain_robot.main --backend mock --video <path-to-video.mp4> --dry-run on the file at <path-to-video.mp4>. Report the motion, looming and motor activity values over the run. Verify that the output shows dry-run and that no UDP packets were sent.

  • Walk someone through an app one control at a time

    Chain several arrows so a person learns each step of an app's interface.

    View prompt
    Use the bigarrow CLI from franzenzenhofer/big-arrow-on-the-screen to show three steps in <app name>, using the element labels <label 1>, <label 2> and <label 3> with the sign texts "1. <text 1>", "2. <text 2>" and "3. <text 3>". Expected output: three `bigarrow start` runs that each return at once. Verify each run exits with code 0 and that `bigarrow stop --all` clears the arrows afterwards.

  • Score your own coding harness on the 30-task set

    Run the evaluation skill to get pass rate, cost, and a report for your harness.

    View prompt
    Use the frontierharness-eval skill from the frontier-harness-eval/eval repo to evaluate <harness repo URL> on one Terminal-Bench task and one DeepSWE task first. Expected output: a normalized results file and a report under runs/<run-id>. Verify that run.json records egress_policy and that methodology_comparable is false for this new run.

  • Test a decision model for option-order sensitivity

    Run the public hard items with options in two orders to see whether your model's answers flip.

    View prompt
    Clone github.com/fstandhartinger/jevbench and load datasets/public/hard.jsonl. Run <your decision model> on each item twice, once with the original option order and once with the options reversed, and output a table of items whose chosen answer changed with the total percentage of flips. Verify that the reference runs in results/v1.2/runs/open-alternative-jev/ are used only for comparison and that your report says the public split can be trained on, so these results are not a held-out score.

  • Replay a finished agent run to review its subagents

    Scrub back through a completed session to see each agent and tool call in order.

    View prompt
    Using the zoetrope repo (furkankly/zoetrope), replay the finished session at <session-file-path> with `zoe` and step through each prompt era. Expected output: a graph showing each subagent and its tool calls at the point it ran. Verify that the tool counts fall when you scrub backwards before reporting the review as complete.

  • Track AI and research feeds from one topic bundle

    Import the AI or research bundle to follow models, papers, and labs without the full directory.

    View prompt
    Using the tidings-rss repo, import tidings-ai.opml and tidings-research.opml into <reader-name>. Return the total feed count and a list of feed titles that published at least one article in the last 7 days.

  • Run FuXi on your own provider key and switch models

    Connect your own API key and change models with /model to manage which provider handles your work.

    View prompt
    Configure the FuXi repo at fuxicodex/Fuxi to use the API key for <provider-name> from the local environment, then start a session. Expected output: FuXi starts and answers a short test prompt using the provider you set. Verify that the request is billed to your own provider account and not to FuXi-managed models.

  • Screen about 950 IDX stocks by valuation and sector

    Filter the IDX universe with one expression, for example low P/E financial stocks.

    View prompt
    Use the idx tool from the fzn0x/idx repo to run `idx -o json stocks screen -f "<filter>"` where <filter> is a rule such as pe 15,sector=financial. Return the matching tickers with their P/E and sector as a table. Verify that the count of results matches the length of the returned data array.

  • Let an AI agent create and edit images on your machine

    Connect Claude or Cursor to Kokon's built-in MCP server so the agent can generate and edit images locally.

    View prompt
    Using the Kokon MCP server in this repo (GabrieleLozupone/kokon), edit the image at <image path> with the instruction '<edit description>' and save the result to <output folder>. Expected output: the path of the new image file. Verify that the file exists and that its dimensions match the source image.

  • Run AI actions on selected text with local or API models

    Send selected text to a local Ollama model, Apple Intelligence, or an OpenAI or Anthropic key from the popup.

    View prompt
    Using the OpenClip repo at https://github.com/ganeshmshetty/openclip, configure one AI provider named <provider> and run an AI action on the selected text <target text> from the contextual bar. Expected output: a model response for that text shown in the popup. Verify that only the provider you chose is configured.

  • Adapt a bundled example into your own biology figure

    Copy the closest example folder, change its biology and rebuild standalone pages.

    View prompt
    In the Garinmckayl/anima repo, copy examples/<closest-example> to examples/<new-subject> and change its build.mjs to draw <new biology subject>, importing only from kit/. Run node on the new build.mjs in dark and light mode. Expected output: two standalone HTML pages. Verify that the new page includes a sources block with a link for each number and an educational-not-medical-advice note.

  • Teach a coding agent to author Framefields videos

    Install the Framefields agent skills so Claude Code, Cursor, or Codex can write and render compositions.

    View prompt
    Install the framefields agent skills from the gatewai-dev/framefields repo, then create a 3 second 1080p composition in <project folder> with the headline <headline text> and render it to output/<name>.mp4. Expected output: a rendered MP4 file. Verify the file exists and that the composition code imports from framefields.

  • Disable TV ad and tracking packages without uninstalling

    Stop sponsored rows and analytics on a Google TV or Android TV while keeping every package and a one-line restore.

    View prompt
    Using the Gathin23/cleanyourtv repo as context, disable only the ad, telemetry and content-row packages found for the TV model <tv-model>, using pm disable-user, and keep the restore script. Expected output: a list of disabled packages and the path to the restore script. Verify that every package still appears in the installed package list after the change.

  • Revise an existing image without losing prior edits

    Edit a picture you already have, or refine the last result, while keeping references attached.

    View prompt
    Using the GPT Image Skill in <repo path>, edit <existing image path> with the change <requested change> and keep the rest of the layout. Expect a new PNG in /generated-images and a PATH=... line. Verify that the previous output was the edit target for any follow-up request.

  • Let a coding agent build decks and workbooks locally

    Install the Genoffice skill so Claude Code, Codex or Cursor can create .pptx and .xlsx files on your machine.

    View prompt
    Install the genoffice skill from the genspark-ai/genoffice repo, then build an eight-slide deck about <topic> in <output folder> as a .pptx file. Expected output: one .pptx file and a rendered preview of each slide. Verify that the deck opens and that no slide text overflows or overlaps.

  • Run a funding-signal outbound workflow with an agent

    Paste a workflow file into an agent that asks for inputs before it sends or spends.

    View prompt
    Read the funding-signal-outbound workflow from https://www.growth.engineer/workflows/funding-signal-outbound.md, ask me for every input it lists, and run its steps in order. Before any message is sent, money is spent or data is changed, stop and ask me, then report each completed step with its result.

  • Route Claude Code through a pool of Claude subscriptions

    Point the official Claude Code client at a local proxy that rotates across several Claude Code accounts.

    View prompt
    In the underclass repo at <repo path>, start the server, export ANTHROPIC_BASE_URL and CLAUDE_CODE_OAUTH_TOKEN as the README describes, and run one short Claude Code task. Expected output: a completed task and a request row for a Claude Code account in the admin page. Verify that the account's plan and its 5-hour, 7-day, and model-scoped windows are shown.

  • Ask Codex about a repo without allowing edits

    Explore an unfamiliar codebase with Codex in Plan only mode, with no file changes.

    View prompt
    Using the gitbot-hq/GitBot package, start it with gitbot start and create a Codex bot with Plan only permissions. Ask it to explain how <feature name> works in <repo folder>. Expected output: a written explanation that names the files it read, with no edits made. Verify that the working files are unchanged after the reply.

  • Find a reference build for a customer workflow

    Locate a working example in the Cases section that matches a customer's AI use case.

    View prompt
    Read the Cases and reference implementations section of global-fde/awesome-fde-resources and pick the two entries closest to a <customer use case>. Output a table with project name, link, fit, and reuse notes. Verify the license stated in each linked project before recommending it.

  • Measure how often memory reuse hits on your sessions

    Run the replay gate on your own transcripts and report the hit rate to the v1.0 tracking issue.

    View prompt
    Using the Gnosil/semantix repo, extract slices from <session.jsonl> into a project named <project>, then run semantix verify for that project. Report the relevance result against the README's 70% gate and the dashboard output. Verify that the sessions you tested are the ones you extracted and that no transcript content is posted publicly.

  • Check published results against bundled records

    Trace a reported metric back to its per-example records and manifest.

    View prompt
    In the repo GongZhiren/State-of-Thought, open results/summaries/ and results/manifest.json, then find the record files that back the metric for <backbone and dataset>. Report the record file paths, the configuration named in the manifest, and whether make check test passes.

  • Check a phone setting from the terminal

    Give ARTEMIS a plain-language instruction and read the result in your terminal.

    View prompt
    In the google/artemis repo, run `uv run artemis run "<instruction>" --profile flash` against the connected device. Expected output: a structured terminal result with a success or failure status and the value the device showed. Verify the reported value matches the on-screen value.

  • Find where a behavior lives by asking from the terminal

    Ask a plain-language question and get the matching code excerpts with file and line citations.

    View prompt
    In the Graphicle-AI/graphicle repository, run `graphicle ask "<question>"` inside <repo-path>. Expected output: an evidence list of cited excerpts, each with a file path, line range and symbol name. Verify by opening the first cited file at the stated lines and checking that the code answers the question.

  • Block risky MCP config changes in pull requests

    Run the audit in GitHub Actions, fail the build on high findings, and show results in Code Scanning.

    View prompt
    Use the GitHub repo graygnatconsole/mcp-audit-tool to add a GitHub Actions workflow to <repo-path> that runs `mcp-audit scan` on the project MCP config files and writes SARIF output. Return the workflow file contents. Verify that the workflow has `security-events: write` permission and that the scan step includes `--format sarif`.

  • Check past failures before changing code

    Query project memory for a known failure before an agent edits the affected code.

    View prompt
    In the repository grpcer/ownmem, ask project memory about <the symptom or proposed change> using `npx ownmem recall -- "<query>"`. Expected output: one of the three delivery tiers, quoted memory, up to three file pointers, or an abstention that names the refusing gate. Verify that any quoted memory shows its trust status before you act on it.

  • Batch-render scene stills at zero credit cost

    Send up to 50 scene prompts to Flow's Agent mode and get matched image files back.

    View prompt
    Using the flow-mcp repo at <repo-path>, send these scene prompts from <prompt-file> to the agent image batch tool in one call. Expected output is one image per scene in ~/flow-mcp-out/ with file numbers that match the scene order. Verify that the returned results list every scene and that the credit count shown is 0.

  • Run the video studio from inside Claude Code

    Install the Mortiflix plugin in Claude Code and let it guide you through setup, a brief and each review gate.

    View prompt
    In Claude Code, install the plugin from GTKottman/mortiflix-oss with `/plugin marketplace add GTKottman/mortiflix-oss` and `/plugin install mortiflix@mortiflix`, then run `/mortiflix demo`. Expected output is a completed placeholder walk-through of every gate. Verify that the guide asks you before installing anything and before starting paid work.

  • Clean AI marks from manuscripts and web copy

    Run the text-only skill on your own documents with no service required.

    View prompt
    Using the clean-user-facing-text skill from the watermarks-remover repo, clean the text in <file path>. Report how many invisible Unicode or exotic space characters were removed, and confirm the visible wording is unchanged.

  • Draw arrows and steps over screenshots for a product tutorial

    Turn product screenshots into a narrated tutorial with arrows, circles and numbered steps.

    View prompt
    Using the khan-explainer skill, build a draw-over-UI tutorial from the screenshots in <screenshot folder> that shows a new user how to <task>. Expected output is a tutorial MP4 with arrows and numbered steps drawn over the screenshots. Verify with the contact sheet that every step points at the correct part of the screen.

  • Connect an AI agent to shared context over MCP

    Give an agent a key that fixes its namespace, actor, and role on the server before it reads or writes.

    View prompt
    In the halofy repository, go to kernel, generate a key for namespace org/support/agent-1 with keygen, and start the MCP server with that key. Report the namespace and role the server resolves for the agent, and confirm that the MCP tool schemas do not accept caller-supplied identity fields.

  • Rehearse a risky file change before it touches your folder

    Let an agent do a task on a copy of your folder, compare attempts, and apply only the one you want.

    View prompt
    Using the Bloks repo at hamedgitty/bloks, rehearse the task <task-description> on a copy of the folder <target-folder> with the agent in Bloks. Expected output: a change card listing each changed file with its line count and diff, with Apply and Discard buttons. Verify that the real folder <target-folder> is unchanged until you press Apply.

  • Watch coding plan and OpenCode Go quota before you hit a limit

    Show rolling usage percentages and reset times for supported coding plans and OpenCode Go in the sidebar and quota strip.

    View prompt
    Using the dsh-cost-meter plugin in DeepSeek Harness 0.2.0 or later, read the current usage percentage and reset time for each enabled coding plan window and for OpenCode Go, then list any window at 80 percent or more. Verify that the values match the sidebar quota cards for the same vendors.

  • Find free credit for a model without a card

    Look up official free tiers and trial credit for a model, and see whether a card or ID check is needed.

    View prompt
    Use the Grandet free-credit lookup at https://grandet.ai/api/v1/free-credits?q=<model or provider> to list free credit offers for <model or provider>. Return each offer with whether a card, ID check or application is needed, and flag any offer that needs a card.

  • Show a listening indicator during voice input

    Display a pausable listening orb that freezes when recording stops.

    View prompt
    Using the ThinkingOrbs repo (https://github.com/haplollc/ThinkingOrbs), add a ThinkingOrb(.listening, isPaused:) indicator bound to the recording state of <target voice screen>. Return the SwiftUI view code and confirm the orb pauses when isRecording is false.

  • Test a NightRun image in QEMU before flashing

    Build a NightRun image with a Llama model and boot it in QEMU to check it without touching hardware.

    View prompt
    Use the repo hardrave/NIGHTRUN to convert the model at <target> (a GGUF file path) into models/model.nrm and boot it in QEMU with cargo xtask run --img --mem 4G --window. Expected output: a QEMU window showing the NightRun chat prompt. Verify the nrconvert step reports that it re-validated its own output before you boot.

  • Point Claude Code or Cursor at a local model

    Use the Anthropic-compatible endpoint on port 30001 so agent CLIs run on your own box.

    View prompt
    Use the repo hasso5703/dgx-spark-qwen38 to connect claude-code on a laptop to the local Qwen3.8 lane on <box-address>. Expected output: a reply to a short test prompt returned through the Anthropic protocol on port 30001. Verify that the request is answered by the box and that no hosted API key is used.

  • Shrink messages in a Python app before each LLM call

    Add a compress() call to existing Python code so the model receives fewer tokens.

    View prompt
    Using the repo headroomlabs-ai/headroom, add a compress() call to the LLM request in <file-path>, passing the message list through headroom's compress function before the provider call. Expected output: the same answer with a printed token saving. Verify that the request still succeeds and that tokens_saved is greater than zero for a payload with repeated JSON.

  • Have Claude design a custom skin from a short description

    Describe a mood in plain words and let Claude build and apply a skin you can keep.

    View prompt
    In a Claude Code session with the hellosverre/claude-skins plugin installed, ask Claude to make a skin that feels like <mood description>. Expected output: the skin is applied and listed by `/skin list`. Verify that the new skin name starts with my- when a built-in skin was repainted.

  • Test typed decisions in the browser with no backend

    Run the WebGPU playground to try customer service, security, and invoice decisions locally.

    View prompt
    In the repo openJev-verdict-2.0, open the webgpu-demo folder and start a local server on port 8080 with python3 -m http.server 8080. Then test three sample decisions from <sample file> in the page at http://localhost:8080. Expected output: the results for each sample, and verify that the page loads in Chrome or Edge with WebGPU enabled.

  • Move a SillyTavern JSONL chat into Agent RP

    Attach a SillyTavern JSONL log to a character session so the old chat carries over.

    View prompt
    In the repo hewzhew/dsh-agent-rp, use the migration panel described in the README to migrate <path-to-chat.jsonl> with the character card <path-to-card>. Report the new session name and the message count. Verify that the source JSONL file and the original session are unchanged.

  • Compact or hand off a heavy chat before the cache goes cold

    Use the cache countdown on the bar to decide when to compact or start a fresh chat.

    View prompt
    In the HeyCubit/effortless repo, after installing the plugin, check the bar's cache countdown in a chat at <path-to-project> and report the minutes left. Once the bar shows the cache as cold on a large chat, confirm that Compact or Handoff is offered and that a summary is written.

  • Gate CI on new PHP debt only

    Baseline today's findings, then fail pull requests only when a branch adds new ones.

    View prompt
    In the Heyosseus/sloppy project, set up a baseline for the PHP repository at <project path> by running the baseline command, then run the CI command. Output the number of accepted baseline entries and the CI result. Verify that the CI command reports no findings on the unchanged branch.

  • Start from a template and adapt it to your needs

    Copy a finished app or site into your own account, then describe the changes you want.

    View prompt
    Using the HeyPuter/builder live demo at https://builder.puter.com/, copy a template that fits <target project> into a new project, then request changes that match its purpose. Expected output: an edited project copy in your account. Verify that the original template is unchanged and the copy shows your requested changes in the live preview.

  • Route drafting and review to separate model groups

    Use custom task branches so drafting and review each get the model that fits their category and difficulty.

    View prompt
    Using the HiRoute repo at https://github.com/higress-group/HiRoute, configure a routing plan with separate drafting and review custom task branches for <target project>. Report which model group each branch uses and the category HiRoute chose for two sample turns. Verify that a low drafting score does not change the review category.

  • Run multi-round research with cited sources

    Search internal documents and public sources, then inspect the evidence behind each answer.

    View prompt
    Using the repo himovo/movo, deploy it locally with ./movo up and upload <document folder> to the knowledge area. Run a multi-round research question on <topic> and return the answer with its citations. Verify that every claim links to a cited source.

  • Give an AI agent a country-aware document generator tool

    Connect the Yowes MCP server to an agent that lists countries and schools before generating samples.

    View prompt
    Connect to the yowes MCP server from the hirotomasato/yowes repo over stdio. Call list_countries_tool, then list_schools for <country code>, and report the country codes and school names found. Expected output: a list of valid options with no documents created until asked. Verify that every returned country code matches one of the 13 in the README table.

  • Create a 3D model from a reference picture

    Attach a photo or a viewport screenshot so the agent builds a matching model in Blender.

    View prompt
    In the hitkeeen/blender-ai-addon AI Copilot chat, attach <reference image path> and ask the agent to build a blockout model matching it. Expected output: a Python script that creates objects in the scene resembling the reference. Verify that the chosen model is vision-capable and that the add-on reports a successful run.

  • Keep agent sessions running when a provider fails

    Set an ordered fallback list so a failed provider hands the request to the next model.

    View prompt
    In the my-free-code repository, set MODEL_SONNET to <primary-model> and FALLBACK_MODELS to <fallback-model-1>,<fallback-model-2> in .env, then start the gateway with python -m my_free_code. Expected output: a test request completes using the primary model. Verify that the gateway falls through to the next model when the primary is made to fail before output.

  • Let an agent build and edit FreeCAD models from the terminal

    Point an AI agent at the FreeCAD CLI to run design commands without opening the GUI by hand.

    View prompt
    Using the HKUDS/CLI-Anything FreeCAD CLI, create a simple box model with the installed command set and save it to <output-path>. Report the command used and the file path. Verify that the output file exists and is not empty.

  • Run the Howseen example film locally and re-render it

    Render the included Howseen launch film from its source to learn how the skill is structured before you change it.

    View prompt
    In the claude-motion-design repo, run the examples/howseen-launch project and render the full film to out/video.mp4. Expected output: a 60 fps MP4 and probe/sheet.png. Verify that the probe sheet shows the four frames at 1, 8, 15 and 20 seconds.

  • Run Implement and Review on one repo from the Windows app

    Use the portable Windows build to have one agent write in a worktree while another reviews.

    View prompt
    Using the Hoylon/peerbridge-mcp portable build, start an Implement + Review operation on <path-to-local-git-repo> with Codex as writer and Claude Code as reviewer. Report the worktree path and the Trust Timeline status, and verify that the review shows no stale-evidence warning.

  • Let an agent fix a failing mobile build on its own

    The device_run tool builds, launches, reads the error, and retries the fix.

    View prompt
    In the MobileCode repo at https://github.com/hsandhu/mobilecode, use the device_run tool to build and launch the <platform> app in the project at <project-path>. Read the build error and log tail on failure, fix the code, and rerun. Report the final status and the changed files. Verify that the last run reached Running before stating the build is fixed.

  • Watch every epic on your machine in a browser

    Open one local web view that lists all epics on this machine.

    View prompt
    Using the humanize repo (hmz), run `hmz web` and open the local page it prints. Report the number of epics listed and their names as plain text. Verify that the count matches the epics you started earlier on this machine.

  • Let an AI agent draft a post with write approval

    Connect Claude Code, Cursor, or Codex to a site and enable writes once for that CLI.

    View prompt
    Use the Hycli MCP server (command `hycli`, args `mcp`) to prepare <site-url>, list its actions, and ask me before enabling writes. After I approve, create one draft post on <site-name>. Expected output: a confirmation that the draft was created. Verify the draft appears in the site account before anything is published.

  • Continue a community decomp using your own game copy

    Fork a decomp.dev project and let agents match more functions, committed to git for review.

    View prompt
    Using the decomp.wtf repo (i12bp8/decomp.wtf), fork the decomp.dev project <project-name> and add my own copy of the game at <path-to-game>. Run the agents and report how many functions were matched as git commits on the decomp-wtf branch. Verify that each commit only changes C or C++ sources and headers, and that no matched function broke.

  • Score agent output against a locked, auditable rubric

    Have the Architect define a weighted rubric, then get evidence-backed scores that the kernel computes, not the agent.

    View prompt
    Use the KADATH runtime in this repository to create a run for the review goal <goal>. Confirm that the approved benchmark states the weighted rubric and automatic failures, and report whether the top agent's score cites evidence references for each credited item.

  • Compare several design directions side by side

    Ask Claude Code for multiple design options and view them together in the terminal before choosing one.

    View prompt
    Using the claude-show-your-work plugin in Claude Code, generate <number> design directions for <target screen> and show them side by side in the chat. Expected output: the directions displayed together, with each new draft kept in History. Verify that all directions appear in the same view and that earlier drafts can be reopened.

  • Redraw a figure in WPS Presentation as an editable PPTX

    Build an editable PPTX working copy of a figure in WPS Presentation with checkpoint refreshes.

    View prompt
    Using the scientific-illustrator plugin with host_application set to wps, redraw the uploaded reference figure as an editable PPTX working copy in WPS Presentation. Verify that target_application is wps, microsoft_powerpoint_used is false, and refresh_verified is true for each region.

  • Check token use and estimated cost of a Codex task

    Review task and turn token totals, cache usage, and estimated cost in one viewer.

    View prompt
    Using the icesixgod/codex-trajectory repo, open the trajectory for the Codex task <sessionId> and report its token totals, cache usage, and estimated cost. Verify that the cost is labeled as an estimate based on bundled API prices, not a subscription bill.

  • Have an AI assistant write tests that follow team rules

    Use the bundled rules and write-time hook so Claude Code or Cursor produces tests in the project's required style.

    View prompt
    In the agentic-playwright repo, write a Playwright test for <feature-under-test> using the Constitution and skills under .claude/. Expected output: a spec with page objects, Given/When/Then steps, web-first assertions, and one tag. Verify the file has no waitForTimeout, XPath, or any type, and that `npm test` passes.

  • Produce a literature review on a topic in one command

    Run /ars-lit-review on a topic to get a single-shot literature review draft from the Deep Research skills.

    View prompt
    Using the repo Imbad0202/academic-research-skills in Claude Code, run /ars-lit-review on the topic <topic>. Expected output: a literature review draft with citations. Verify that every citation resolves to a real paper that supports the sentence it is attached to.

  • Compare fixed-depth and early-exit decoding on Ouro

    Measure how loop depth settings change Ouro-1.4B outputs for a chosen set of prompts.

    View prompt
    In the vllm-rlt repository, use the Python API to run Ouro-1.4B on the prompts in <prompt file> twice, once with fixed four-loop decoding and once with the early-exit gate. Output a table with prompt, both answers, and the loop depth used. Verify that both runs use the same prompts and the same decoding settings except for the exit policy.

  • Build a full arrangement part by part with the AI arranger

    Add drums, bass, strings or a new section to a track in the DAW instead of re-rolling the whole song.

    View prompt
    Using the repo inikolax/remiqora, open the DAW project <project name> and use the AI arranger to add a <part type> part on top of the selected lanes. Expected output: one or more variant lanes that match the project tempo and key. Verify that each variant sits on its own lane and that the project tempo is unchanged.

  • Tour uncommitted changes before you commit them

    Read your own uncommitted work as a guided tour to catch risks before others review it.

    View prompt
    In the repository at <path>, run tour on the uncommitted changes and report which files the tour points to first. Expected output: a list of file names from the tour. Verify with `git status` that the working tree is unchanged after the run.

  • Model a race-safe code redemption test on the published one

    Use the 25-way simultaneous redemption test as a pattern for testing your own voucher or credit system.

    View prompt
    In the Inkloom-art/inkloom repository, locate the test that sends twenty-five simultaneous redemptions of one code. Summarise its three assertions and describe, in plain steps, how a similar test could be written for a different database. Verify by quoting the assertion lines and the file path they come from.

  • Build a Godot 4 game with engine checks

    Have Noobi AI build a Godot 4 project, then import, validate and export it through the host.

    View prompt
    In the Noobi.ai repo at <path>, install dependencies with `npm ci`, start the app with `npm run dev`, and submit a Godot 4 game brief: <game idea>. Expect a Godot 4 workspace with a Compatibility-renderer Web export; verify that the environment and export-template checks passed before counting the run as complete.

  • Review what a coding agent changed, file by file, from iPhone

    Check per-turn file changes and word-level diffs from a coding agent while away from the computer.

    View prompt
    Using the Innei/lody-ios repo README, describe how to review a coding agent's file changes for one conversation turn from an iPhone. Output a short numbered procedure that names the Turn Changes Overview and the diff viewer. Verify that the output does not claim features the README does not list.

  • Score your build against a reference site and fix the gaps

    Band-map your page and diff its motion against a reference, then iterate to a passing score.

    View prompt
    Use the awwwards-mcp server to run verify_build comparing my local build at <build file:// path> against the reference <reference URL>. Expected output: a 0 to 100 score, a pass, warn, or fail verdict, and evidence lines naming each band or motion gap. Verify the score changes after you apply one fix and re-run the check.

  • Turn a repo's current work into one HTML summary page

    Build one self-contained HTML page that summarises a branch or work tree, ready to view or send.

    View prompt
    In the git repo at <path>, use the summary skill from isas1/skills to build a single HTML page of the current branch. Expect one self-contained HTML file with no external assets. Verify that each changed file named on the page appears in git status or git diff.

  • Classify a dataset of records in one call

    Pass up to 500 records as items and ask the same questions of each one.

    View prompt
    Using the evaluate tool from the itsmostafa/system-one-connector repo, pass the records in <file path> as items (up to 500) and ask whether each one is negative in sentiment using a score question. Return one answer per record as CSV. Verify that the number of returned rows equals the number of input records, and list any that failed.

  • Run 204,800-token context on a 12 GB card

    Serve a 2.3 bpw Qwen3.8 model with SJ-KVaRN cache on an RTX 3060 12 GB or similar card.

    View prompt
    In the llamAmpere repo at <repo path>, build llama-server and start the 2.3 bpw 12 GB command from the README on a 12 GB card. Send a prompt of about <token count> tokens to the local server and report the reply plus the peak GPU memory from nvidia-smi. Verify that the context setting is 204800.

  • Stress-test a fix for a flaky test

    Let 32 competitors attack and defend a proposed fix before you commit to it.

    View prompt
    Use the arena skill from https://github.com/Jakeschincariol/arena-skill to run /arena --agents 32 on the flaky test in <test file>. Expected output: the winning fix, the attacks it survived and the round count. Verify the result by running the project's own test suite before you apply the change.

  • Calculate real margins, break-even and payback

    Run unit economics on your numbers to see profit per sale, break-even and cash needed.

    View prompt
    Using the Jakeschincariol/founder-skill repo, build founder/numbers.json for <business name> from the prices and costs I give you, then run `python3 skills/founder-cfo/unit_economics.py founder/numbers.json --out founder/cfo.md`. Output the contribution per sale, break-even per day and year 1 totals from cfo.md. Verify that every number traces to an input and that missing fields produce an error rather than a guessed value.

  • Strip AI tells from a draft and score it before posting

    Clean invisible characters and stock phrases from any draft, then get a five-check human score.

    View prompt
    Use the li-human scripts in https://github.com/Jakeschincariol/linkedin-agent-skill on <path to draft file>. Run humanize.py with --report, then detect.py, and return the cleaned text, the change report and the HUMAN SCORE. Verify that the score is shown for both the original and the cleaned file.

  • Send poses and speech to the robot from any script

    Call the robot's HTTP API from a custom agent, hook, or script to set animations and play speech.

    View prompt
    Use the HTTP API in the repo github.com/jamro/tiny-engineer, documented in docs/api.md. Send one POST /anim request to the robot at <robot address> and report the HTTP status and response body. Expected output: a success response and a visible pose change on the robot. Verify the robot moved before you send anything else.

  • Flip through your Obsidian notes with pinches

    Point a board orb at your Obsidian vault and open your notes as glass cards with hand gestures.

    View prompt
    In the barehands repo, add a notes orb to barehands.json that points to <vault path>, then confirm the file is valid JSON. Expected output is the updated config and a note that the Notes orb is ready. Verify the path resolves to a folder that contains .md files.

  • Set up Intermission on Windows with Rio

    Install Rio, add the ConPTY files and the Visual C++ Redistributable, then enable pictures for Claude Code.

    View prompt
    On this Windows machine, follow the intermission README Windows steps for Rio, then run /intermission in Claude Code from jarrodwatts/intermission. Confirm both conpty.dll and OpenConsole.exe are beside rio.exe and that the game pane shows pictures. Report any step that failed.

  • Turn your coding chats into a fine-tuning dataset

    Extract, secret-scan, and load your assistant conversations as a training set for a chat model.

    View prompt
    Using the repo jatechan/ai-data-extractor, extract the sources cursor and claude_code, run detect-secrets on the output, and load the JSONL files in <project folder>/extracted_data with the datasets library. Report how many conversations remain after filtering for assistant messages. Verify that no record still contains a flagged secret before using it for training.

  • Continue a Pi CLI session in the Percho window

    Pick up a terminal Pi session in the visual app without losing its history.

    View prompt
    In the repo Jaxton07/percho, check that the shared ~/.pi/agent/ directory is the one used for sessions, auth, and model settings. Report which session from <session-name> is visible in the Percho sidebar and whether its prior messages load.

  • Answer agent approvals and questions from the HUD

    Allow, deny or answer an agent's request from the HUD and jump back to its session in one click.

    View prompt
    In the agent-hud-open repository, run `make run` and confirm the app is open. Trigger one approval request from Claude Code or Codex, then verify the request appears on the HUD with its command or diff and report what options it offers.

  • Find what depends on a table and who owns it

    Use OLCF Intelligence to follow table lineage and see the confidence and gaps for each edge.

    View prompt
    Use the open-lakehouse-compute-fabric repo (jddevtime/open-lakehouse-compute-fabric). Run `olcf intelligence` against the local installation, and for <table name> list its upstream and downstream assets with the confidence level of each edge. Verify that every edge has a confidence value and that gaps are listed with reasons, not guessed.

  • Check whether AI engines cite your site for one question

    Ask one buyer question to AI engines and see whom the answers cite.

    View prompt
    Using the geo-score repo at jianruntech/geo-score, run geo_score.py on <target-domain> with --ask set to <buyer-question>, using the API key already present in the environment. Expected output: each engine's answer and its cited sources. Verify that the report lists whether <target-domain> is cited.

  • Compile a session into a Docker-validated coding task

    Review a candidate, build an executable bundle, and run two-state Docker validation on it.

    View prompt
    Using the EvoTrace repo at https://github.com/jinzijian/EvoTrace, run /review 1, /build 1, and /validate 1 in the DeepSeek Harness app for the candidate <candidate-number>. Report the asset status and the Docker validation result from /runs. Verify that the asset is marked Verified only if the base was rejected and the reference was accepted.

  • Fix a bug and every same-pattern copy in one pass

    Reproduce a bug, find the same pattern across the task's scope, and add a check that stops it returning.

    View prompt
    In the <repo-name> repo, use fix-the-class on this bug: <bug-description>. Expected output: a reproduction, the bug class name, every same-pattern hit in the task's scope with its fix or record, and the check added. Verify that the new check fails against the code before the fix.

  • Run the pinned OpenCode engine on a project

    Install the locked OpenCode dependencies with Bun and start its dev command against a chosen project folder.

    View prompt
    In the pixelcrabs repository, change into upstream/opencode, run `bun install --frozen-lockfile`, then run `bun dev <absolute-path-to-project>`. Expected output: the OpenCode dev process starts against that project. Verify with `bun dev --help` that the command runs before pointing it at a project.

  • Build a driving or racing level from a real road

    Use a real road from the map as the level for a driving, racing or endless-runner game.

    View prompt
    In the jonwheatley/pixel-path repo, read the commented pseudo-3D renderer and bake a route from <start place> to <end place> with the pixel-path skill. Expected output: a route folder and a short written summary of how the renderer draws the road. Verify that the route folder has index.html and that the summary names the renderer's main functions.

  • Turn Claude Code into a disciplined investigator

    Install the Lemmalog skill so Claude Code uses the engine as working memory for debugging, audits and multi-step research.

    View prompt
    In <repo path>, use the lemmalog skill to track a debugging investigation of <bug description>. Expected output: a list of hypotheses with status and a decision, each backed by a lemmalog query result. Verify that the final report cites engine query output for each claim.

  • Make the robot track your face as you move

    Use your Mac camera so the robot's servos keep you in view while you move around.

    View prompt
    In the groki-bot repo, read gateway/README.md and set up dynamic face tracking with the Mac camera for <robot-name>. Report whether the servos move when a face moves in front of the camera.

  • Check a release download against the signed checksums

    Confirm the AppImage or package matches the maintainer's signed SHA256SUMS before running it.

    View prompt
    In the jpzk/opensidian repo, download SHA256SUMS and SHA256SUMS.asc for v0.6.2 into <download-folder>, import the key listed in the README, and run gpg verify and sha256sum -c. Report the gpg verification result and each OK line. Verify that the gpg output shows a good signature from the expected key fingerprint before reporting success.

  • Chat with a frozen model to inspect byte output

    Load your trained weights and chat without changing them, to see how it spells and closes quotes.

    View prompt
    In the jrz97619761/test-model-thing repo, using existing trained weights, run `python main.py   chat --frozen` and send five test prompts. Report the outputs and check that the weights file is unchanged afterward.

  • Pick one shared playlist for a batch of clips

    Send up to 20 clips to analyze_batch and get a mood cluster plus one mini-playlist for the series.

    View prompt
    Using the sonicmatch MCP server from js713-lab/sonic-match-mcp, run analyze_batch on these clips: <list of up to 20 clip paths>. Return the mood cluster and the shared mini-playlist. Verify that the batch contains no more than 20 clips and that each playlist track lists its license.

  • Gate promptfoo eval results before a release

    Convert promptfoo JSON output into a portable artifact and run a policy gate on it.

    View prompt
    In the EvalForge repo (https://github.com/jsdhwfmax/EvalForge), convert a promptfoo results file at <promptfoo-results-path> with `evalforge import promptfoo <promptfoo-results-path> --output build/evalforge-artifact.json`, then run `evalforge gate build/evalforge-artifact.json --policy examples/promptfoo_policy.json`. Expected output is the gate verdict; verify the adapter accepted results schema 3.

  • Review the ASM plan before calibration runs

    Pause after the plan is written, check or edit asm_plan.md, then let the run continue.

    View prompt
    Use the AutoWWTP-ASM repo in <repo-folder>/code/langgraph-en to run <task-file> with the --hitl-plan option. Expected output: a paused run with midoutput/asm_plan.md ready for review, then the completed asm_report.md. Verify that the plan names the target tank or process section and the target state variables before continuing.

  • Rewrite on-the-nose dialogue in a scene

    Revise a scene whose characters say exactly what they feel, using the dialogue and scene craft skills together.

    View prompt
    Using the screenwriting-skills repo (sw-dialogue and sw-scene-craft), revise the scene in <pasted scene text> so that the characters stop stating their feelings directly and the conflict shows in action. Return the revised scene and a list of changed lines with reasons. Verify that the character names and the scene's facts are unchanged.

  • Pull On Co cancer records into a script via CLI or API

    Use the onco command or the static JSON API to load cancer records into your own analysis.

    View prompt
    Using the OnCo JSON API at https://onco.cc/api/v1/ and the OpenAPI schema at https://onco.cc/api/v1/openapi.json, fetch all records of the kind <kind name> and write them to a CSV file with the attribution line "Data from OnCo (onco.cc)" in the header. Verify that the row count matches the endpoint's reported count and report any record missing a primary link.

  • Score a live website like an Awwwards jury

    Get a scorecard with screenshots and measurements for any reachable site.

    View prompt
    Using the juliobsz/skills repo, run the /jury skill on <target URL>. Expect a .jury/scorecard.md file with screenshots, Core Web Vitals measurements and a ranked fix list. Verify that each score in the scorecard links to a screenshot or measurement in the .jury folder.

  • Triage incoming support tickets with Automations

    Let scheduled agent runs classify and triage Customer Support Desk tickets in the background.

    View prompt
    Using the xyne-spaces repo at <repo-path>, set up a ticket triage and classification automation for the Customer Support Desk. Expected output: a list of tickets with a classification and queue for each. Verify that each ticket is classified only from ticket content the signed-in user can access.

  • Cluster broken agent runs into one issue per failure

    Collapse dozens of failed runs into a single counted issue with a suggested evaluator.

    View prompt
    In the Tracely-ai repository, run `docker compose --profile demo up -d --build --wait`, then open the clusters view at http://localhost:3001. List the top three clusters with their counts and suggested evaluators. Verify that the counts add up to the total number of failed traces shown.

  • Inspect why a verified answer was grounded

    Call the five-stage workflow and read its sources, grounding result, and public trace.

    View prompt
    Use the jzjzzzzzzz/agent-me API at localhost:8000 to send the verified collaboration request for <question>. Return the workflow, grounded status, sources, and the trace stage outcomes as a short table. Verify that run_id is present and that each trace stage lists its outcome.

  • Audit an SVG logo against design principles

    Check an existing SVG logo for construction faults and test it at 16 px and in one colour.

    View prompt
    Using the audit and test tools in kaankiziltug/logo-design-skill, audit <path to logo.svg> against logo principles and build a 16 px and one-colour test sheet. Return the list of issues and the sheet image path. Verify that the audit was run on the same file you passed in.

  • Make a model's dimensions adjustable without code

    Have the agent expose key values as parameters so you can change a size without touching the code.

    View prompt
    In the SOMA model folder for <model name>, make the values <dimension list> in the model file into adjustable parameters, run `soma build`, and confirm that the build succeeds. Verify that each parameter is listed in SOMA and that changing one value changes the model size.

  • Shortlist a robot-use method for a manipulation project

    Compare listed methods and their evaluation settings to pick one to reproduce or adapt.

    View prompt
    Use the Methods & Frameworks section of https://github.com/kairunwen/Awesome-Robot-Use-Agent to shortlist two or three methods for <task description on <robot>>. Output a table with method name, evaluation benchmarks, and code release status as stated in the README. Verify that each code status matches the Details and sources note for that entry.

  • Turn a talking-head video into a captioned TikTok

    One render command crops to 9:16, burns in your cue text and normalizes loudness for TikTok.

    View prompt
    Using the ffmpeg-skill repo, render <talk video> with the tiktok template and the cues file <cues.txt>. Expected output: a 9:16 TikTok MP4 with captions and a platform check written next to it. Verify the check result and the output resolution before reporting success.

  • Create a sound effect and export it for Godot

    Describe a sound by its source, action, material and space, then export it as OGG.

    View prompt
    Using the audio-studio MCP server from the audio-studio-mcp repo, call generate_audio with audio_type sfx for a heavy wooden door slamming in a stone hallway, filling sound_source, sound_action, sound_material and sound_space. Then call process_audio with peak normalization and OGG output. Verify that the OGG file is in outputs/ and that its .json sidecar lists the sfx settings.

  • Keep the prompt cache warm during breaks

    Install cache-tax to keep the prompt cache warm and see the estimated cost of a cold send.

    View prompt
    Using the karanb192/awesome-claude-code-mods repo, find the cache-tax mod and confirm it is listed as a prompt cache warmer. Expected output: its install path, access details and the note that warming uses tokens and needs a one-hour cache. Verify the one-hour cache requirement before recommending installation.

  • See the rewrite price before a cold send

    Get a warning with the estimated cost when a message would rewrite an expired cache, then choose to resend or start fresh.

    View prompt
    In the karanb192/cache-tax repo, with the cache-tax plugin installed, run /cache-tax in a resumed Claude Code session. Report the cache estimate and cold-write tally, and state whether the guard is set to warn or refuse. Verify that the guard mode matches the value you set with /cache-tax guard.

  • Plan FY 2026-27 advance tax payments and due dates

    Get the next advance-tax amount and its due date from your expected income and TDS.

    View prompt
    In the itr-wala repo at <repo-path>, run the advance-tax validator and engine on a FY 2026-27 income file for <your-income-file>. Expected output: the amount to pay next and its due date, with late fees and interest excluded from the target; verify the validator accepts the file and that no future payment is counted as already paid.

  • Show a client several ranked redesign options

    Generate multiple ranked directions from one source page for a side-by-side client review.

    View prompt
    Use the reimagine-it repo to create review options for <path-to-page.html> by running `npx reimagine-it variations -i <path-to-page.html> -n 4 -o <review-folder>/`. Expected output: ranked redesign pages plus a contrast sheet in the review folder. Verify that the pages share the same source facts and that the contrast sheet lists each direction.

  • Stress-test a plan or design doc before building

    Have agy challenge a plan from several angles before you commit to it.

    View prompt
    Using the keli-wen/agy-staff plugin, ask the reviewer persona to challenge <plan file path> in <repo>. Expect a multi-angle critique of the plan. Verify that each objection points to a specific section of the plan.

  • Compare Claude Code, Codex and Cursor on one project

    Run several coding agents side by side on the same project to see which one fits a task best.

    View prompt
    Using the BetterC0de repo's side-by-side conversations, give the same task text to Claude Code, OpenAI Codex and Cursor Agent for the project at <project-path>. Produce a short table of each agent's proposed file changes and one note per agent. Verify that each agent was connected and that every table row names a real file in <project-path>.

  • Add cheaper lane subagents to Claude Code

    Install four Jev lane subagents, each with its own model and effort, into Claude Code.

    View prompt
    Use the hermes-jev-skills repo from kerpopule to install the four Claude Code lane subagents on this machine. Run `python3 install.py --check` first and report what it would change. Then run the install and confirm that jev-lane-small, jev-lane-escalate and the two between them exist in ~/.claude/agents.

  • Self-host a private team design canvas with Docker

    Run Doop's production build with Docker so your team designs on infrastructure you control.

    View prompt
    In the repo kgoedecke/doop, start the production stack with `BETTER_AUTH_SECRET=$(openssl rand -hex 32) docker compose up -d`. Confirm the app answers on http://localhost:4400 and report the HTTP status code returned for the root URL.

  • Publish the town as a static site on any host

    Build Factory Yard to plain HTML and JS and host the output anywhere.

    View prompt
    In the repo Khalidabdi1/factory, run `npm install` and `npm run build`, then report the file list in out/. Verify that out/ contains plain HTML and JS files before saying the site is ready to host.

  • Turn agent requests into numbered steps you can follow

    When the agent needs you to run, paste, click or approve something, get exact numbered steps instead.

    View prompt
    In the open-steps repo at <repo-path>, use the os-step-by-step skill for the next action that needs a human on <project-name>. Expected output: numbered steps a non-technical person can follow, with only the actions that truly need the person listed. Verify that the agent tried every step it could do itself before asking.

  • Resume an interrupted corpus task without guessing

    Check recorded runtime state before any agent writes to a half-finished knowledge corpus.

    View prompt
    In the Cambium-governed repo at <repo-path>, run the resume status check and report the recorded task, any locks or holds, and the exact next_action. Do not write any files. Verify that the check reports no errors before you propose the next step.

  • Count and export your repeated prompts

    Run the extractor alone to list, count or export your prompts with no agent involved.

    View prompt
    Using the cli-faq-shortcuts extractor at ~/.agents/skills/faq-shortcuts/scripts/extract_asks.py, run it on <project_path> with --format jsonl and write the records to a file. Expected output: one JSON object per line with date, source and prompt fields. Verify the file line count matches the count from the default tsv output.

  • Turn receipt photos into searchable table records

    Drop receipt images into an attachment field and let vision-powered fields fill in vendor, category, and text.

    View prompt
    In the Kition desktop app, open the table <table name> that has receipt attachments and AI extraction fields. Ask the Agent to total the category values for the rows marked <month>, and check that each total matches the corrected rows before you use it.

  • Let an agent zoom into one moment of a recording

    Give the agent the command set to pull dense frames around a timestamp, a spoken phrase, or a mark.

    View prompt
    Use the scrawl command on the capture at <bundle-path>. Run `scrawl inspect --marks`, then `scrawl zoom --at <timestamp>` for the first mark, and report what happens in those frames. Verify that the reported timestamp matches the summary.md timeline.

  • Probe a brand-new session before a long task

    Run the Fresh session probe to see which model a new Codex session gets right now.

    View prompt
    In the kiyoakii/is-gpt-nerfed repo, trigger a probe of the Fresh session from the menu bar app or with `nerfed probe now`, then report the verdict and the model you selected. Verify that the verdict is one of Match, Suspicious, Downgrade, Upgrade, Rerouted, Downgraded, Upgraded, Unlisted, or Invalid.

  • Check backend and frontend health before editing code

    Run the full verification suite so changes to agents, APIs, or the UI can be checked.

    View prompt
    In the kkjiangk/agent-py repository, run the backend and frontend verification commands listed in the README Verification section. Report the pass or fail result of each command. Verify that the backend pytest run has no failures before you propose any edit.

  • Let an AI agent look at and operate a phone

    Connect Claude Code or Cursor to a phone through MCP so it can read the screen and act.

    View prompt
    Using the Droidline repo at https://github.com/KnifeLemon/Droidline, register its MCP server with the paired phone, then dump the current screen and list every element with its text and id. Verify the list includes <expected element text> and report it back as JSON.

  • Tune LLM generation parameters in a simple chat client

    Adjust nearly all model parameters in one place and test how replies change.

    View prompt
    Using the Chat_UI repository at KODAMA-TECHNOLOGY/Chat_UI, set up the configuration for <api-endpoint>, send the test prompt <test-prompt> at two parameter settings, and export the history. Report the two replies and the exported file name, and verify that both replies appear in the exported history.

  • Design an agent task input with full states

    Get a Task Input component that covers loading, cancellation, invalid input, and recovery.

    View prompt
    Use the component-builder skill from kostja94/bricks to build a Task Input for <target project>. Cover loading, cancellation, invalid input, and result recovery, reusing the project's existing primitives. Verify the component inside its real page and report which states were tested.

  • Try Jev routing rules in the browser Playground

    Paste a sample message, add questions, and read typed answers without writing code.

    View prompt
    Using the repo kraayenjon/awesome-jev and the TypeSafe Playground, test a routing rule on <sample messages file>. Add one Choice question and one Noul question, run each example, and produce a table of message, choice, confidence, and noul value. Verify that the table covers every sample and flag any answer where the choice does not match the message.

  • Test lid-close behavior before a long unattended run

    Run a short watched session and check the lid-close actions and log before trusting it overnight.

    View prompt
    In the repo https://github.com/krishhgg/Insomnia, read docs/lid-close.md and docs/recovery.md, then tell me which lid-close actions are on by default for this Mac. Output a short checklist for a test session of <test-minutes> minutes. Verify the checklist against the README before reporting.

  • Batch restore a folder of videos from the command line

    Run Jasna on a whole input folder in one command and save the results to an output folder.

    View prompt
    Using the Jasna repo at Kruk2/jasna, run `jasna --input <input folder> --output <output folder>` on the Jasna release. Expected output: one restored file in <output folder> for each input file. Verify that the number of output files matches the number of inputs and that each plays.

  • Have an agent draft a Triton-Ascend kernel

    Point the agent at the kit's guides and project rules before it writes kernel code for Ascend NPU.

    View prompt
    In the triton-ascend-agent-dev-kit workspace, read AGENTS.md and triton-ascend-dev-doc.md, then draft a Triton-Ascend kernel for <target-operation> and save it as <output-file>. Expected output: the kernel file plus a short list of the guide sections you used. Verify the kernel's Triton-Ascend calls against the official Triton-Ascend documentation before calling it done.

  • Tell Claude Code panes apart in Herdr's goto panel

    Give each Claude Code pane its own name so the goto panel stops listing every one as claude.

    View prompt
    Using the repo kryptamine/herdr-auto-title, set up Claude Code pane naming on <target machine> by running the Herdr integration install for claude and restarting the plugin. Report the goto panel entries for two open Claude Code panes and confirm they show different names instead of claude.

  • Review monthly subscriptions and cancel the ones you do not want

    Andee lists your subscriptions with the monthly total, then walks you through cancel, keep or think about it.

    View prompt
    Using the Andee repo at github.com/kuafuai/andee, read the subscription page on the phone and list each subscription with its monthly cost and a total. Expected output: that list with the total on top, and no cancellation made yet. Verify that Andee stops before the final confirm and does not enter any payment password.

  • Add /compact advice and optional auto-compact to Claude Code

    Install the Compact Adviser plugin in Claude Code with function hooks enabled.

    View prompt
    In Claude Code on <target machine>, add the kunchenguid/compact-adviser marketplace, install compact-adviser@compact-adviser, and start claude with CLAUDE_CODE_ENABLE_FUNCTION_HOOKS=1. Expected output: the /compact-adviser command appears and /compact-adviser status reports a key source. Verify that the environment variable is exactly 1 before reporting success.

  • Import asset data from ScopeSentry into the asset graph

    Connect ScopeSentry with its address and API key, then import domains, IPs, and ports by project or task.

    View prompt
    Using the repo kutukam/autonomous-pentest-agent, connect it to a ScopeSentry instance at <scopesentry-url> with the API key <api-key>. Import the assets from project <project-name> and report the count of assets in the asset graph. Verify by listing the imported assets in the 资产 page before you start any exploration.

  • Prototype typed yes/no, choice, and score questions over JSON state

    Write your own nested state and declare Noul, Choice, and Score questions to test how the typed readouts behave.

    View prompt
    Using the repo at https://github.com/kyegomez/open-jev, write a script that builds a state dictionary from <your record file>, declares one Noul, one Choice, and one Score question, and prints the answers. Expected output is one typed answer per question; verify that every Choice answer is one of the declared options.

  • Measure lesions on CT or MR and export a PDF or CSV report

    Draw length, angle and ROI measurements on images, then export the results as CSV, PDF or DICOM SR.

    View prompt
    Work in the repo l5769389/voxenra. Start it with `uv run voxenra`, open <path to study>, and measure the lesion with a length tool. Export the results to <output folder> as CSV and confirm the file lists each measurement with its value.

  • Confirm a fix works without recording it

    Re-ask Perch about a finding after you change the code, without saving anything.

    View prompt
    In the perch repo at <project path>, after editing the code for finding <id>, run `perch check <id>`. Report whether the problem still appears. Verify that the check did not add a new record to the scan results.

  • Approve or deny agent actions from your wrist

    Get a card on the watch when an agent asks for permission and allow or deny it in one motion.

    View prompt
    In the chums repo at <target-folder>, run bin/chums-permissions and confirm the permissions step completed for the agents. Expected output: the agents' permissions granted once. Verify by checking that bin/chums-doctor reports the permission check as passing.

  • Dub a script or subtitle file line by line

    Import text or subtitles, assign a voice to each character, and generate every line in the desktop app.

    View prompt
    Using the leemysw/yovoice repo, help me set up a Story dubbing project from <script file> with one voice per character in <character list>. Expected output is one generated audio take per line; verify that every line in the script has a generated take before export.

  • Run Minke in development mode from a source checkout

    Stage the pinned DeepSeek Harness runtime and launch the Minke development app.

    View prompt
    Using the lencx/Minke repository, set up a development build from a fresh checkout and report the result of each step. Expected output: a log summary showing that harness:stage completed and that pnpm start launched the app. Verify that the vendor/deepseek-harness submodule is populated before running any build command.

  • Create a 12-second vertical video for Reels and TikTok

    Render a 1080x1920 product clip that follows your brand colours and typeface.

    View prompt
    Use the cinetic skill from the Leonxlnx/cinetic repo to make a 12-second 1080x1920 vertical video with sound for <app name>, using the brand colours <hex values> and typeface <font name>. Output an MP4 and confirm the brand colours and typeface were used exactly as supplied.

  • Split a large task into parallel agent leaves with scoped claims

    Run independent leaves in fresh agent contexts using scoped pipelines and ownership claims.

    View prompt
    Use the unlazy skill in the repo <repo-path> to split <large-task> into scoped leaves with disjoint OWNS: paths. Claim each ready leaf, then run node /scripts/gate-check.mjs --scope <scope-name> and report the reduced result. Verify that the output says ALL MET before you report success.

  • Get a compact semantic tree of a page for a model

    Export a short structured text outline of a page, sized for model context windows.

    View prompt
    Using the repo lexmount/moli, run `moli fetch --dump semantic_tree_text --wait-selector body <target-url>`. Return the semantic tree text. Verify that headings and links from the page appear in the output.

  • Build and query Jev Mem over your own observations

    Load your JSON notes into a Jev Mem cache with live models and ask questions answered from retrieved evidence.

    View prompt
    In the Jev-Mem repository at <target-folder>, build a cache from <input-json-file> using `python -m jev_mem --mode build` with config/jev_mem.json, then query it with `--mode query` using the question <question>. Return the answer and confirm that the cache folder was created locally.

  • Get a scene structure review before any edits

    Have the assistant read the object structure of an existing scene and explain it before it changes anything.

    View prompt
    Using the mcp-for-blender-pro repo, ask the Blender assistant to inspect the open scene and explain its object structure without changing anything. Return the object hierarchy and material list, and verify that get_scene_info and list_objects were the tools used.

  • Turn many web pages into typed rows in one call

    Fetch a list of URLs in one browser batch and return a few extracted fields per page.

    View prompt
    Use the aside-codemode execute_code tool to call browse.exec on the URLs in <url list>, extracting the title and first link, and return the items array. Verify that each row has a status and that pages that failed are reported rather than hidden.

  • Let Claude answer AI visibility questions from your data

    Connect Claude to a local Limelit instance so it can read your visibility data in plain language.

    View prompt
    In the limelit-co/open repository, register the MCP server with `claude mcp add limelit -s user -- sh -c 'cd ~/limelit && exec ./limelit mcp'`. Then ask it for the visibility of <brand-name> against <competitor-name> across all engines. Expected output is a plain-language summary with the sample size behind each figure. Verify that the first tool call reports the instance state.

  • Turn an AI coaching reply into a plan on your watch

    Paste an AI-written week of workouts into Zepp Bridge, adjust each session, and send it to a compatible watch.

    View prompt
    Using the ZeppBridge repository, draft a seven-day running plan for <athlete goal> based on my records from <date range>, in the format ZeppBridge accepts. Expected output: a plan file ready to paste into the app. Verify that rest and sleep suggestions are kept as notes only, since they are not sent to the watch.

  • Install the ranking data as a skill for an agent

    Install the Best Skills repo as a skill so an agent keeps the rankings as standing context.

    View prompt
    Use the best-skills skill installed from https://github.com/LinklyAI/best-skills. Name the ranking list that answers this question: <your question>, then give the CSV file path and its top three rows. Verify that the file path exists in the repo's data/ folder.

  • Call the local model from scripts over HTTP

    Send chat requests to the local server from your own code, with optional streaming.

    View prompt
    Using the lithos-metal repo at https://github.com/lithos-ai/lithos-metal, with the server running via `lithos-metal serve --model nvidia/Qwen3.8-27B-NVFP4`, write a short script that sends <your prompt> to http://127.0.0.1:8000/v1/chat/completions and prints the reply. Expected output is the model's text reply. Verify the script receives an HTTP 200 response before reporting success.

  • Have an agent install the shop and verify it loads

    Let an agent run the non-interactive install steps and confirm the plugin is in the profile.

    View prompt
    For the LivXue/dsh-plugin-shop repo, list the profiles in ${DSH_HOME:-$HOME/.dsh}/profiles, then run `dsh plugin --profile <profile> add [email protected]`. Expect a list output from `dsh plugin --profile <profile> list --depth 0` that includes dsh-plugin-shop, and also check that dsh.profile.bundles in <profile>/package.json includes the plugin.

  • Turn a research direction into a ranked proposal

    Use AutoVibeIdea to map literature, rank candidate ideas and draft a proposal.

    View prompt
    In the repo liyingze07-svg/EffectiveAutoResearch-EAR-, follow docs/getting-started.md to run AutoVibeIdea on the research direction <research-direction>. Expected output is a literature landscape, ranked candidates and a proposal draft in its own workspace. Verify that each candidate's novelty judgment cites retrieved prior work before you rank it highest.

  • Check RSI claims against the list's three evidence levels

    Sort a set of self-improvement papers by task gain, retained gain, or improver gain.

    View prompt
    Using the awesome-rsi README at lobehub/awesome-rsi as the source of definitions, classify the papers named in <paper list> as task gain, retained gain, or improver gain. Output a table with columns for paper title, evidence level, and missing evidence. Verify that each classification is supported by the paper's own abstract, not only by its README summary.

  • Share a live agent conversation with teammates

    Open the same agent conversation with teammates to review the transcript, files, and changes.

    View prompt
    In the LodyAI/Lody repo, find the shared conversation <conversation-name> in the workspace <workspace-name> and summarize its transcript, runtime status, and code changes for a teammate. Output a short summary with the current status and the files changed. Verify the summary against the output of `npx lody session list --workspace <workspace-name>`.

  • Query Jev projects by domain from a terminal

    Install the Agent Skill so a terminal or agent can search projects and pinned source evidence.

    View prompt
    Run `npx skills add logicrw/awesome-jev-projects`, then query the installed Awesome Jev skill for projects in <domain>. Expected output: a list of matching projects with pinned source evidence for <target>. Verify that each returned entry names its license and fixed-version material before you use it.

  • Compare answers from Codex and Claude Code in one thread

    Ask one question, switch agents mid-thread, and dig into the answer that fits best.

    View prompt
    Using the longsurf-ai/endo repo, set up a chat where <my question> is answered first by Codex, then by Claude Code in the same thread. Expected output: two answers in one thread, with the second agent referring to the first. Verify that the Claude Code answer reflects the earlier history.

  • Explain what moved a chart with sourced annotations

    Select a price range and have your agent research the move, with source-linked notes pinned to the bars.

    View prompt
    In the OpenChart app, select the bars from <start date> to <end date> on the <symbol> chart and ask the agent what moved the price. Expected output: annotations pinned to those bars, each with a source link. Verify that each annotation links to a source you can open before you rely on it.

  • Verify that a graft unloads cleanly and stays bound to its model

    Check the reversibility and model-id claims before a model deployment is signed off.

    View prompt
    In the repo lordx64/phantom-kv, test the claim that unloading the graft returns <model id> to baseline behavior. Run identical greedy prompts before loading, with the graft loaded, and after unloading, then compare outputs and file hashes. Expected output: post-unload outputs and weight hashes match the pre-load baseline exactly. Verify that a load attempt with a different model id is rejected before reporting success.

  • Track net worth and holdings on your own computer

    Keep banks, brokers, cash, holdings and debts in one local app that stays on your machine.

    View prompt
    In the aurelio-finance repository, start the app on my own data for <target OS> and list the Wealth and Portfolio entries it shows. Verify that the records are saved to backend/data.db on this machine.

  • Trace a theorem's dependencies before reading its proof

    See direct and recursive dependencies, shared prerequisites, and unknowns for one chosen result.

    View prompt
    Using the papergraph-mcp repo, run get-dependency-reading on the paper <paper id> in workspace <workspace> for result <result id>. Report the direct dependencies, shared prerequisites, and unknowns. Verify that every listed dependency links to a source slice and that unknowns are not presented as established.

  • Push lot availability to road signs and Home Assistant

    Send capacity and space changes over MQTT to LED signage or Home Assistant automations.

    View prompt
    For the repo lotvulture/lotvulture, configure an MQTT alert in the Lot Vulture dashboard that fires when lot capacity reaches 95 percent, targeting the broker at <mqtt_broker_address> and topic <topic_name>. Report the alert configuration you created and the message payload received, and verify that a test occupancy change produces exactly one message on the topic.

  • Track coding agents and approve them from iPhone

    See agent progress on your iPhone Lock Screen and approve permissions with Face ID when you step away from your Mac.

    View prompt
    Using the Louis-CFM/coucou repo, set up the Coucou Mac app and iPhone app so that a Codex session on <target Mac> shows as a Live Activity on <target iPhone>. Expected output: the agent state appears on the Lock Screen, and an Allow tap is confirmed with Face ID. Verify that the Mac applies only the decision for the request it is waiting on.

  • Fork a built-in tool to change how it works

    Copy the shipped bash tool, rename it, and change its behavior for one agent.

    View prompt
    Using the repo lploc94/raw-cli, copy examples/tools/bash/ to ~/.config/raw/tools/<tool-name>/, change its manifest id and name, and select local/<tool-name> in the agent <agent-name>. Expected output: a successful run of one shell command through the forked tool. Verify the run output shows the forked tool name and a status line.

  • List hardcoded URLs in an APK with one SQL query

    Run a single CLI query to find which methods reference a specific URL inside an APK.

    View prompt
    Run the dexsql CLI against <path to APK> with a query that selects distinct methods from method_strings where value equals <URL>. Report the method names returned and confirm the count matches the number of rows printed.

  • Start a contest project from official problem files

    Copy the official problem files into a new project folder with fixed file identities.

    View prompt
    Use the Modeling Workbench repo in <tool folder> to start a new contest project. Use <official material folder> as the official material and <new project folder> as the output folder. Confirm the contest name, year and paper language, then report the copied file list and the stage that comes next.

  • Check each research claim against its source page

    Audit every finding in a MISAKA conclusion against the file, page and quotation it names.

    View prompt
    In the Luciole-Studio/Misaka-Agent project folder <project folder>, open the card and conclusion Markdown files and check that each cited claim matches the file, page and quotation it names. Expected output: a list of citations that match and a list of those that do not. Verify that every finding includes a quotation from its source.

  • Narrow a DSH skill catalog to the skills a task needs

    Recommends a configured number of relevant skills and ranks file glob results, without changing what the main agent loads.

    View prompt
    Using the repo luobosibing2/dsh-jev-plugin, enable Skill selection and File ranking in a DSH profile named jev, then send the task <target task description>. Report the recommended skills and their order. Verify that the main agent still loads the original skill.

  • Turn your own video of an object into a 3D capture

    Extract frames, add object masks, run Pi3X cameras, then let the agent rebuild the object.

    View prompt
    Using the agenticSTAR repo, convert <video-file> into a capture with tools/video_to_frames.sh and tools/make_capture.py, then run tools/run_kf.sh with --agent claude on the resulting capture. Expect mesh/object.glb and mesh/pose.json under runs/. Verify that the mask folder has one PNG per extracted frame before starting the run.

  • Pick the next tool call from a fixed option list

    Give AgentJev the current state and a list of allowed next actions, then route to the top option.

    View prompt
    Using the agent-jev repository at <repo-path>, send the state in <state-file> with a choice question listing the allowed next actions in <action-list>. Return the top option, top_probability, and margin. Verify that the returned option is one of the options you supplied.

  • Collect RGB-D camera data from a simulated scene

    Place scene cameras, calibrate, annotate and record data for a dataset where the engine supports it.

    View prompt
    Using the ManfredCh/Lyapunov repo, read docs/CAPABILITY_MATRIX.md and docs/SCENE_CAMERA_PIPELINE.md, then set up RGB-D capture for the scene <scene-name> on the engine <engine-name>. Report which camera types and dataset export options are supported for that engine. Verify support against the capability matrix before recording.

  • Block abusive or spam text in Laravel form submissions

    Add a validation rule that asks a yes/no question about each submitted text and rejects the bad ones.

    View prompt
    In the marcreichel/laya-php repo's Laravel setup, add a Decides::not rule with the question <moderation question> to the <form field> validation in <controller or form request>. Report which test inputs pass and fail, and verify that a request with a fake answer of true is rejected.

  • Test the agent in a laptop chat first

    Run the agent on your laptop and chat with it before you buy any phone line.

    View prompt
    In the open-instinct repo at <repo path>, follow the laptop quick start from the README with a test name <name>. Expected output: a reply from `pnpm instinct chat` after `pnpm instinct dev` is running. Verify that a follow-up chat asking what you like gets an answer that mentions the saved preference.

  • Publish one SEO article every weekday

    An SEO/AEO Employee researches keywords, publishes an article and reviews rankings on a schedule.

    View prompt
    Using the ai-employees repo, install the SEO/AEO Employee into <target folder> and confirm its routines are scheduled. Expected output: keyword research, a first article and a rank review in the employee's folder. Verify that each article is reviewed before it is published on your site.

  • Use Command Code models in the dsh terminal UI

    Add the plugin to the dsh-tui profile and select Command Code models from /model.

    View prompt
    Add @mars-sea/[email protected] to the dsh-tui profile of dsh and confirm /model lists commandcode models. Expected output: a commandcode entry with plan and context annotations in /model. Verify that /commandcode opens the usage dashboard.

  • Practice web pentesting on vulnerable apps

    Aim REDCELL at local intentionally vulnerable apps to learn how agent-driven testing works.

    View prompt
    Using the repo martian56/redcell, start the local practice targets from docker-compose.targets.yml and run a session against the Juice Shop at http://localhost:3000. Expected output: a list of recorded findings and an exported JSON report. Verify that the findings reference the local target and not any external host.

  • Assign work to the farm from your phone

    Talk to your farm's Claudes from the Claude app and hand them tasks from anywhere.

    View prompt
    Install clodfarm from github.com/matank001/clodfarm with the one-line install script, then open the farm UI at http://localhost:8080. Send the task <task description> from the Claude app under Code, then confirm the new sub-agent appears in the farm UI and report its status.

  • Build a support assistant from your website and FAQs

    Crawl your site, add files and FAQ pairs, and set a help desk for hand-off.

    View prompt
    In the ciele repository, set up an assistant that answers from <target website URL> and escalates to a help desk when no answer is found. Report the embed snippet and the result of one test question that should escalate. Verify that the escalated question appears as a handed-off conversation before reporting success.

  • Split a plan into tracer-bullet tickets with blockers

    Turn a conversation into a spec, then into ordered tickets that declare what blocks what.

    View prompt
    In the mattpocock/skills repo, use to-spec on our current discussion about <feature>, then use to-tickets to split the spec into tracer-bullet tickets. Expected output: a published spec and a ticket list where each ticket names its blocking tickets. Verify that no ticket is blocked by a ticket that depends on it.

  • Record task and delivery closures only from real outcomes

    Write terminal task states and delivery states from a Python worker without guessing success.

    View prompt
    Using the MaxHu-xuan/task-state-guard repo, write a short Python script that creates a task in <ledger-path>, starts it, and closes it as succeeded only after your worker reports success. Verify that you call set_delivery with delivered only after a real transport acknowledgement, and report the final task and delivery states.

  • Review a Compose screen against UI and state traps

    Have an agent check a Compose screen against the visuals, screens and state trap indexes.

    View prompt
    Using the installed kotlin-footguns skills, review <path to screen file> against the compose-visuals-footguns and compose-screens-footguns indexes. Expected output: a list of matched trap files with the line in the screen that triggers each one. Verify that each cited trap file exists and that its trigger description matches the code you point to.

  • Flash a pocket tank onto a board from a browser

    Install the firmware on a supported Waveshare board from the install page, with no toolchain.

    View prompt
    Open https://pocketank.com/install/ for the pocket-tank project from the mediacutlet/pocket-tank repo and report the install steps shown for the connected board. Verify that the settings page on the tank reports a version after install.

  • Onboard to a repository with Repo Memory

    Build repository knowledge from recent issues, pull requests, and commits before making changes.

    View prompt
    Use the MemoraX Code skill to build Repo Memory for the <repository name> repository, retrieving only the latest 3 issues, pull requests, and commits. Report the architecture map, entry points, and module ownership you found. Verify that each claim is tied to an issue, pull request, or commit in the retrieved records.

  • Save a memory snapshot and resume it in a new session

    Store a model's memory state to a file and restore it later without the old chat transcript.

    View prompt
    Using the MemTensor/MemT-1.0 repo and a running MemT-1.0-Nano server, save memory from a session to <snapshot-name>.safetensors, then restore it in a new MemTSession. Expected output: restored.messages has length 0 and a reply to a fact-based question is correct. Verify the returned snapshot path is used as the state argument.

  • Let the assistant sign in using a vault

    Store site logins in an encrypted vault so autofill keeps passwords out of the model.

    View prompt
    Using the repo Merit-Systems/OpenInstinct, deploy the app and save a login for <target site> in its vault. Expected output: confirmation that the login is saved and that a later task signs in without the password appearing in chat. Verify that the private Blob store is still present before finishing.

  • Distill a harness into Qwen3.5-9B weights

    Fine-tune the base model on reviewed trajectories so it runs well under the minimal harness alone.

    View prompt
    Using the repo metaevo-ai/harness-zero, train a LoRA SFT run from sft.jsonl on Qwen/Qwen3.5-9B with run name hz-demo. Expected output: a training run under runs/train. Verify the confirmation prompt shows the intended dataset and settings before you approve the submission.

  • Tighten an abstract to 200 words without losing results

    Get replacement abstract prose and a short change note from one prompt.

    View prompt
    Use the game-the-llm-reviewer skill from Michael-Jiahao-Zhang/game-the-llm-reviewer on the abstract text in <path to abstract file>, keeping it under 200 words. Work only from the supplied text, preserve both positive and negative results, and return replacement prose with a short change note. Verify that no result, number, or limitation is missing from the new version.

  • Find a library's getting-started guide in docs

    Point Jevry at a project's public documentation site and have it navigate to the getting-started page.

    View prompt
    Use the repo michaelswissa/jevry: run npm run dev, then ask the desktop app to find the getting-started guide on <docs-url>. Expect the browser to end on that guide page; verify the page title and heading match what you asked for.

  • Schedule a recorded task as a recurring Automation

    Turn an approved analysis into an Automation that runs the same procedure on a schedule or trigger.

    View prompt
    Use the Skill Recorder repo at microsoft/skill-recorder to build an Automation from my approved analysis of <recurring task>. Expected output: a scheduled Automation that runs the same ordered procedure. Verify on the first scheduled run that the output matches what you recorded.

  • Hear what Claude did after each turn

    Turn on Narrator to have Claude speak a summary of each turn in your language.

    View prompt
    In a Claude Code session with the better-claude narrator plugin installed, run /narrator to turn it on, then send the prompt 'list the files in <target-folder>'. Expected output: a spoken summary after the turn in the language used in the session. Verify that the summary matches what Claude actually did in that turn.

  • Install a fast Apple TV-style home screen

    Build and install the TV Home launcher with a dock of your favourite apps and rotating nature wallpapers.

    View prompt
    In the tv-home repo, edit launcher/res/values/config.xml to set the dock to <app1>, <app2> and <app3>, then run launcher/build-and-install.sh against the TV at <tv-ip>. Report the build result and whether the install succeeded. Verify that pressing Home on the TV opens the new launcher and shows those three apps in the dock.

  • Run a research project from the terminal without the Web build

    Use the FOREST CLI and API service to create and monitor a research project on a server or in scripts.

    View prompt
    In the FOREST repository at <repo path>, run the headless install, start the service with a data directory of <data dir>, and initialize a project with the goal <research goal>. Report the output of the status command. Verify that the project name in the status output matches the name you passed to init.

  • Check whether an agent's 'done' claim is verified

    Open a task receipt and separate the agent's own Reported result from checks that passed after the last change.

    View prompt
    Use the agentacct repo at https://github.com/mikehasa/agentacct to open the receipt for the task <task name> and report whether its result is Reported or Verified. Confirm that any passing checks ran after the last recorded change, and list any earlier failed checks that remain in the history.

  • Tear down a test launch and list what remains

    Remove the resources golive created, then get a handoff for anything it cannot delete.

    View prompt
    Use the golive skill in the repo <repo-path> to tear down only the resources golive created for this app, and show the plan before any deletion. Report the handoff list of leftovers that golive could not remove, and confirm the removal of the test host project.

  • Share a configured bot team as one file

    Save a working team as one file a colleague can import without your chat history or keys.

    View prompt
    Using the OpenMausBot repo at github.com/milind-soni/OpenMausBot, export the team named <team-name> with Share team and list every item the dialog says the file contains. Expected output: that list and the file path. Verify that the list contains no chat history, keys, passwords or model choices.

  • Point an existing OpenAI SDK app at self-hosted Core

    Change the base URL and key so an OpenAI SDK app runs agent Sessions on your own Core.

    View prompt
    In the MiniMax-AI/OpenAgentCore repo, follow the README Quickstart to point an existing OpenAI SDK app at a Core installation at <API base URL>. Change only OPENAI_BASE_URL and OPENAI_API_KEY, then run <app test command> and confirm the request returns a Session ID from the self-hosted endpoint.

  • Remove filler and fake stats from marketing copy

    Run one prompt through the copywriting rules to get clear, honest text.

    View prompt
    Apply the antislop filter from the anti-slop repo (https://github.com/miqdadbadjuber/anti-slop) to the draft in <draft-file>. Return a rewritten version and the Delivery Gate PASS/FAIL report. Verify that no statistic in the output is absent from the draft.

  • Generate renderer video block by block with streaming

    Run the renderer one block at a time with a bounded KV cache for step-by-step generation.

    View prompt
    Using the AgentGarten repo at <repo path>, write and run a script that streams the renderer block by block with Cosmos3Stream for the first-frame anchor at <anchor latent path>. Expected output: a sequence of committed blocks for the conditions in <conditions path>. Verify that the number of committed blocks equals the number of condition blocks before reporting success.

  • Serve a Code as World model behind an OpenAI-style API

    Expose the 4B or 9B checkpoint through vLLM so other tools can send video requests to it.

    View prompt
    In the Code-as-World repo at <repo_path>, start the vLLM server for weights/4b with the served model name code-as-world-4b using the flags in the README's OpenAI-compatible serving section. Then send one chat request containing <video_or_frames> and return the model's text reply. Verify that the server lists code-as-world-4b as an available model before sending the request.

  • Check a finished run for missing scores before sharing

    Verify that an evaluation run has every expected score before you publish a leaderboard row or report.

    View prompt
    In the HarnessEval-W repo, run harnesseval verify run with --eval-root set to <your-eval-root>, --manifest set to <your-manifest>, and --model set to <your-model-id>. Expect the verify command to confirm that all expected scores exist. Check that summary.json and LEADERBOARD.md agree on the overall score before you report the run as ready.

  • Make a capture app handle iPhone Duo's two front cameras

    Get camera direction, mirroring and preview right on a device with two front-facing cameras.

    View prompt
    Using the iphone-duo-camera skill from mirzaaghazadeh/iphone-duo-skills, review <path-to-capture-code> for virtual front camera use, individual camera selection, direction coordinator handling and mirroring. Output the changes needed with reasons, and verify that the change handler is written against AVCaptureDeviceDirectionMap as the README describes.

  • Pause agent runs for human approval

    Stop each run after gates report, then approve, reject, or rework it.

    View prompt
    In the ESF repo at <esf_path>, check run <RUN_ID> with `./bin/factory describe run <RUN_ID>` and list its gate results and the patch it produced. Report whether the run is waiting for review and what the reviewer should check before approving, and do not approve it yourself.

  • Let ChatGPT use files and terminal in a Codex task

    Connect ChatGPT to a Codex task's files, terminal, and tools through MCP.

    View prompt
    Using the codex-chatgpt-web repo, guide the setup of Full harness mode for the Codex task in <project folder>. Confirm the connector name is exactly Codex Native2 and that Verify runtime reports it as attached and available. Do not enable auto-approve; report any approval prompts you see.

  • Review only the lines a pull request changed

    Run Jev Lint on a diff so findings land on new code and cost less.

    View prompt
    In the repository <repo-path> on a feature branch, with TYPESAFE_API_KEY set, run `npx jev-lint review --base main` and list each finding with file, line, rule and score. Verify that every finding points at a line the diff actually changed.

  • Answer several typed questions about one message

    Get a team choice, an urgency score and a refund yes/no flag in one call.

    View prompt
    In the laya-mlx repo (github.com/mizorewww/laya-mlx), write a script that loads aac6fef/laya-mlx and asks three questions about the message in <message_file>: a choice for department, a score for urgency with three rubric levels, and a noul for whether the customer asks for money back. Print the answers. Verify that the urgency value falls between 0 and 2.

  • Count or summarize code with one script, not many reads

    Have the agent write a short script that prints only the result, using ctx_execute.

    View prompt
    Using the context-mode ctx_execute tool, write a javascript script that lists each .ts file in <target-directory> with its line count and prints only those lines. Return the printed output and confirm the count for one file by reading it directly.

  • Check whether one product is worth buying

    Pull details, buyer reviews, sellers and price history for a single Digikala product.

    View prompt
    Use the Digikala MCP server at https://digikala-mcp.mmdju.workers.dev/mcp. For product <product id or name>, call product_details, product_reviews (buyer-only), product_sellers and product_price_chart, then write a verdict on price, seller and reviews. Verify that the verdict cites the product URL and states prices in Toman.

  • Audit a Robinhood Chain token before buying

    Run a token audit from the terminal or Discord to check security before any trade decision.

    View prompt
    Using the noraz-agent repo, run a live token audit on <token-address> through the Terminal TUI or the #audit-on-demand channel. Expected output: an audit summary that includes the GMGN and GoPlus security results. Verify that the audit result is shown before any buy or swap action is taken.

  • Run a live web search endpoint from the terminal

    Call the TinyFish search endpoint with your own key and read the JSON result.

    View prompt
    In the monid repo, set TINYFISH_CREDENTIALS_API_KEY from the environment and run deno task engine:run 'tinyfish#search' with a query of <your query>. Report the returned output and confirm it is a JSON result.

  • Triage an unknown executable to see what it can do

    Combine capability, format, and string tools for a first look at a binary.

    View prompt
    Using the morluto/awesome-reverse-engineering list, select the triage tools from its File identification and triage section that fit a Windows PE file. Run or describe the steps for <target-file> and report the file type, notable imports, and capabilities. Verify that the report states that checksec flags are not a vulnerability verdict if you include ELF checks.

  • Compute a gcd and Bézout coefficients from the terminal

    Install the Python package and get the gcd and Bézout coefficients of two integers as JSON.

    View prompt
    Install the repo morluto/jacobian with `python -m pip install jacobian`, then run `jacobian run integer.compute.extended_gcd` with the payload {"left":"<a>","right":"<b>"}. Report the gcd and Bézout coefficients as returned in JSON. Verify that a*x + b*y equals the gcd for the returned coefficients.

  • Restore natural skin texture in a smoothed portrait

    Replace plastic-looking skin with clean, low-contrast photographic microtexture while leaving lighting alone.

    View prompt
    Use the xxg-portrait-rebuild-light skill from moskoo/xxg-portrait-rebuild-light to run a texture-only skin repair on <path to portrait>, with S1 scale and P0 finish. Return the edited image, and verify that the lighting, color, and focus match the source while the skin looks clean and not plastic.

  • Check an existing poem video before you publish it

    Run the final media QA on any finished MP4 to catch black frames, silent gaps, and wrong specs.

    View prompt
    Use the final_media_qa.sh script from https://github.com/Mr-funny/hbg-classical-poem-silk-video on <path to final.mp4> and write the output to qa/final. Report any black detection, silence detection, or spec mismatch in the logs and the ffprobe.json. Verify that the frames at 10, 25, 50, 75, 90 percent and the last frame are all present in the output folder.

  • Install the skill as a Claude Code plugin and draw figures

    Add the marketplace and plugin with two commands, then request figures from inside Claude Code.

    View prompt
    In Claude Code, add the MrBongoC/ai-iso-skill marketplace and install iso-figure@ai-iso-skill, then request an isometric figure of <object with pressable parts>. Expected output: one HTML file using plain SVG. Verify that the file opens without external libraries and that a pressed part shows its result.

  • Create a custom agent by describing it

    Describe the job in plain words and get a ready-to-run agent on your shelf in seconds.

    View prompt
    Using the Nami repo at mrdainami/nami, describe a new agent that sorts invoices in <target-folder> and confirm it appears on the agent shelf. Expected output: the new agent listed and runnable with a short sorted result for one invoice. Verify the agent only touched files inside <target-folder>.

  • Let a coding agent draft and risk-check posts through MCP

    Claude Code or Cursor generates and checks posts, then saves drafts for a human to approve.

    View prompt
    Using the yominpost MCP server from github.com/mrlong0129/yominpost, call generate_posts for <your launch material>, run check_post on each draft, and save the passing drafts with save_draft. Expected output: saved drafts with risk check results. Verify that no publish action was taken, since the MCP server has no publish tool.

  • Re-check low-confidence labels with a stronger model

    Use the smart tier so answers under 0.7 confidence get a second opinion.

    View prompt
    Using the classifier-dev repo at classifier.dev, classify each item in <input file> with the smart tier for single-label work. Output a table of item, label, confidence and whether it was escalated. Verify that every escalated row has a label that was returned by the service.

  • Drive an existing anti-detect browser window over CDP

    Attach the server to a fingerprint browser you already run, with optional port self-healing on reopen.

    View prompt
    Use the nuphus-mcp server to attach to the external browser at http://127.0.0.1:9222 and take a browser snapshot of the current page. Return the page title and the first five interactive elements. Verify the snapshot comes from the attached window and not a managed Chrome.

  • Propose a new hazard placard category

    Add a labeled, severity-rated hazard entry to the placard definitions and open a pull request.

    View prompt
    In the mrtinkz/ai-charter repository, add a hazard entry to HAZARD_CATEGORY_DEFINITIONS in src/types/certification.ts for <hazard name>, with a label, severity, and one-line description. Run `npm run build`. Expected output: a passing build and a diff that adds only that entry. Verify the new entry appears on /placards after `npm run dev`.

  • Preview a brain's responses without altering live memory

    Use imagination to inspect possible responses while the live trace and pending feedback stay unchanged.

    View prompt
    Using the Python package cadence-net (repo muellerberndt/cadence), compose a brain with inputs=4 and actions=2, run live() for 50 steps, then call imagine() on <observation sequence> and print each phase's qualified flag. Expected output: the qualified flags and the live action taken afterward. Verify that the live action sequence matches a control run that skips imagine().

  • Ask questions about confidential files without cloud upload

    Chat with a large model in the browser while your documents stay on your own machine.

    View prompt
    Use the GitHub repo mw00/project-maya. Run ./setup.sh --setup on <target machine>, choose Maya-S24, then open the local browser chat and ask a summary question about <document path>. Expected output: a summary generated locally. Verify that the network traffic during the answer stays on the local machine.

  • Draw a flowchart or chart inside a Claude Code reply

    Have Claude answer with a mermaid diagram that draws as colored text, then copy it as art or markdown.

    View prompt
    Using the NahumLitvin/prismantis plugin in Claude Code, ask Claude to explain <process name> as a mermaid flowchart. Expected output: a colored text diagram with one color per box, not raw mermaid source. Verify that the diagram fits the terminal width and that the copy button on the diagram works.

  • Recover the reasoning behind a past decision

    Search your own past instructions and track how a standard changed over time.

    View prompt
    Using the session-knowledge repo, call search_sessions with the query <topic words> and then track_evolution on the same topic. Expect your own past instructions on that topic plus a monthly view of changes. Verify the dates on the returned instructions match the expected period before quoting them.

  • Check release notes and PR replies against venue rules

    Review a professional draft against the rules for its document type before publishing.

    View prompt
    Using the sepia repo, run its review operation on <draft file path> as release notes. Expected output: a diagnosis that names each venue mismatch with its line. Verify that every number in the diagnosis matches the source notes.

  • Run the relay and web app on your own server

    Host the relay that joins your devices on a server you control, so the agent runs in your house.

    View prompt
    Using the nano-muse/nanoMuse repository, follow docs/self-hosting.md to start your own relay with `bash scripts/self-host.sh --local` on <server>. Report whether the relay and the web app started and which address the web app answers on. Verify the web app loads in a browser from that address.

  • Turn your own footage into a scrubbing scroll page in Codex

    Use your own photos and video in Codex to build a page where scroll drives the footage.

    View prompt
    Using the scroll-craft skill in the nateherkai/scroll-craft repo, build a scroll-driven page from my own footage in <media folder> for <target product>. Do not use generated assets. Expected output: a page where the footage scrubs with scroll. Verify that the doctor script reports a full ffmpeg build and that no clip is stuck on a poster frame.

  • Set up Foremerge for a repo's coding agents

    Install Foremerge, initialize the repo, and wire up every agent client you use in one pass.

    View prompt
    In the <repo path> repository, install Foremerge, run `foremerge init`, then run `foremerge setup all` and `foremerge doctor --client all`. Expected output: a per-client result from setup and a doctor report. Verify that setup exited with status zero, since the README says it exits nonzero if any client failed.

  • Add the recipe to Codex with prompt files only

    Install the system instructions in Codex without hook reminders.

    View prompt
    In the repository at <repo-path>, run `node scripts/install.mjs` and confirm that the two managed prompt files were written to the active CODEX_HOME. Verify that the installed config still uses the same model, provider and permissions as before.

  • Fix a confirmed finding with a failing test first

    Turn one verified finding into a red-then-green security fix and a reviewable pull request.

    View prompt
    Using the VulnHunter repo at nealbridges/VulnHunter, run the /vulnhunter-fix skill on the finding <finding ID> in <target repo path>. Return the exploit demo, the RED test output, the GREEN test output, and a pull request link or diff. Verify that the security test fails before the code change and passes after it.

  • Point a coding agent at a Pooled room's model

    Run the Pooled bridge on your computer so Codex or Claude Code sends requests to the room's GPUs.

    View prompt
    In the Nehanth/pooled repository, run `npx @pooled/cli serve "<room-invite-link-or-code>"` and then send a chat request with curl to http://127.0.0.1:8080/v1/chat/completions using model 'pooled'. Expected output: a JSON chat completion from the room's model. Verify that the room's chat shows the request.

  • Turn an error log or chat into a Whale-chan comedy comic

    Plan and render several multi-panel comedy comics from one technical source using the comic skill.

    View prompt
    Using the Neko3000/deepseek-whalechan repo, run the whalechan-image-comic skill on <source text or file> with N set to 5 by default. Output the N-idea table and one multi-panel comic per selected idea. Verify that the table was shown and confirmed before any images were generated.

  • Build planned project features in parallel with subagents

    Split a project's planned features across Web GPT extra-high subagents that run at the same time.

    View prompt
    Using the WebGPT repo (Nhahan/WebGPT), ask Codex to run webgpt xh subagents on the planned features of <project path>. Expect one completed change per planned feature and a short report from each subagent. Verify each change with the project's existing tests before merging.

  • Score Codex changes against quality dimensions

    Install Jev Review for Codex so it scores a change before the final handoff.

    View prompt
    Use the jev-review MCP tool jev_review in the NiazMorshed2007/jev-review server to evaluate the current diff for <feature or file>. Return the 1 to 10 scores and confidence values for each applicable metric, and list the weakest dimensions by priority. Verify that each returned score has a confidence value between 0 and 1.

  • Launch a task in a Herdr pane with the chosen agent

    Let the router pick an agent, open a new Herdr pane, start it, and hand it the task.

    View prompt
    In the agent-router repo, run `router run "<task description>"` from inside a Herdr pane and report the exit code. Verify that a new pane opened with the selected agent running, and that `router session` lists this launch.

  • Split a coding task across Codex and Claude agents

    Give each agent its own workspace and queue, then delegate parts of a task between them.

    View prompt
    In the nightly-labs/openbot repo, set up a Codex agent and a Claude agent in the desktop app, each with a separate workspace under <project-path>. Expected output: both agents listed with queued tasks and one agent-to-agent message sent. Verify that each agent's queue shows the task before reporting success.

  • Generate printable PDF handouts for a chapter

    Build a chapter PDF with answer keys for a class, workshop, or reading packet.

    View prompt
    In the NiluK/worldmodels101 repo, install dependencies, start the dev server, and run `pnpm pdf what-is-a-world-model 1` in a second shell. Report the path of the PDF written to public/pdf/ and confirm the file opens and includes a quiz answer key.

  • Stop AI changes that delete or weaken tests

    Count deleted tests, new skips, and tautological assertions before any review runs.

    View prompt
    Using the no_human repo at <checkout-path>, add the task <issue-url> for the repo at <local-repo-path>. Report whether the tamper guard stopped any attempt for deleted or weakened tests, and cite the event that shows the result.

  • Score whether generated sound follows camera motion

    Use the HelixBench dataset to test if synthesized sound fields track dynamic viewpoint motion.

    View prompt
    Using the NoizAI/Helixbench dataset on Hugging Face and the HelixWorld repo (NoizAI/HelixWorld), generate outputs for the dataset items into <output folder> and compare stereo panning with camera motion for each clip. Expect a results table with one row per clip; verify that the row count matches the number of dataset items.

  • Route tickets on an open LLM with no training or labels

    Use the Decider at level L0 to get stable option probabilities from any open causal LM.

    View prompt
    Using the repo AnyJev (nokia-applied-research/AnyJev), build a Decider on Qwen/Qwen3-8B with HFBackend and route the ticket <ticket text> using a choice question over <option list>. Expected output: a distribution over the options and the level L0. Verify that the distribution is returned for every option and that the level is L0 before acting on the result.

  • Direct the studio from Claude Code or Cursor

    Connect an MCP client to Cozy Clay so an AI agent can edit the scene while you watch the viewport.

    View prompt
    Using the NomaDamas/CozyClay repo, connect the MCP server with `npx -y cozyclay mcp` and ask the agent to block <scene description> in the open studio. Expected output is a scene with the requested characters and camera shots visible in the viewport. Verify that the scene matches the description and that the QA results show no collisions.

  • Get alerts when a balance or payment changes

    Create watches that notify a Slack channel or webhook when balances or payments cross a rule.

    View prompt
    Using the repo noskillish/bankmcp, create a balance watch on the account labelled <account label> with a threshold of <amount>. Expected output: a saved watch returned by list_watches with its rule and webhook target. Verify that the webhook URL is set and that the watch shows the correct threshold.

  • Benchmark agent recovery on AppWorld tasks

    Run the reference AppWorld benchmark to measure Sentry on an agent setup.

    View prompt
    Using the Sentry repo at github.com/nuglifeleoji/Sentry, set up the AppWorld benchmark in benchmarks/appworld/ and run it with configs/providers/openrouter.yaml. Before starting, verify that APPWORLD_ROOT points to an existing data folder. Report the run command's final status, any error it printed, and where its output was written.

  • Block AI-tell copy from merging with a strict scan

    Use the scanner's exit codes and JSON output to fail a check when a draft still has copy tells.

    View prompt
    In the humanizer-stack repo at <repo path>, run python3 scripts/copy_scan.py --strict on <copy file> and capture the exit code and the output from --json. Report each hit with its line number and whether the file passed. Verify that a file with no hits returns exit code 0.

  • Confirm the services repo passes format, lint, tests, and schema checks

    Install dependencies and run make check to validate the code and the Prisma schema before editing.

    View prompt
    In the NuvexNetwork/nuvex-services repo, run `pnpm install` and then `make check`. Report which of the steps (format, lint, tests, Prisma schema validation) passed or failed, and quote the first error line if any. Do not start a database, since make check does not need one.

  • Organize one project into a Context Room

    Gather a project's sources, decisions, and documents into one bounded Room for scoped agent work.

    View prompt
    Using the EverRoom repository at <repo path>, read README.md and list the steps needed to set up a Context Room for the project <project name>. Output a numbered checklist that names the Room, sources, and Context Docs to create. Verify that each step uses a feature the README lists as available.

  • Caption the microphone live as you speak

    Show a live text transcript of your speech, with silence filtered out by a voice activity model.

    View prompt
    In the nyosegawa/speech.cpp repo, after installing speech, run `speech asr reazonspeech-v2 --vad silero-vad --live` and speak one Japanese sentence into the microphone. Expected output: the sentence appears as text in the terminal after you finish it. Verify that the words shown match what was said.

  • Find the root cause of a bug before fixing it

    Have the agent work through a four-phase root cause process, then confirm the fix with evidence.

    View prompt
    Using the Superpowers skills from the obra/superpowers repo, apply systematic-debugging to this bug: <bug description>, in the project at <project path>. Expected output: a root cause statement, the fix, and verification-before-completion evidence. Verify that the agent names the root cause before it edits any code.

  • Let a coding agent search project decisions before writing code

    Store decisions as OKF concepts and have the agent search them before it edits anything.

    View prompt
    Using the okf-memory/okf-agent-memory repo, search the project knowledge for <topic> with the okf search command before you write any code. Report the concept IDs returned and the decision each one records. Verify that you read the full concept with the show command before making changes.

  • Match a mountain skyline to a power line site

    Use nearby power lines and the ridge line in a photo to narrow a location in a region.

    View prompt
    Use the geo-sleuth skill from the Oldcircle/geo-sleuth repo to narrow where <path to photo> was taken, using power lines and the ridge line in the photo. Expect a single candidate site with its fit score and a satellite image of the line of sight. Verify that the score and the files produced by terrain.py fit are cited in the answer.

  • Read a water or gas meter into the Energy dashboard

    Point an ESP32-CAM at a meter and log its total and rate in Home Assistant.

    View prompt
    Using the VisionState repo at https://github.com/oleost/VisionState, configure a reading sensor for the camera <camera_entity> on a <water or gas or power> meter. Expected output: a meter total entity that appears in the Home Assistant Energy dashboard. Verify that each new value is higher than or equal to the previous one.

  • Compare typed-decision models on shared benchmarks

    Use the Benchmark and Leaderboard section to run the same public tasks on two candidate models.

    View prompt
    Using the Benchmark and Leaderboard section of https://github.com/OmniJev/awesome-jev-gallery, collect the public evaluation suites and their task counts, then produce a table of <model A> and <model B> accuracy on one shared suite. Verify that both models were scored on identical tasks before you report a difference.

  • Run the One Jev API and playground in Docker

    Start a Compose stack that detects your hardware and serves the API and playground on port 8000.

    View prompt
    Using the OneJev repo at https://github.com/OmniJev/OneJev, run `cp docker/.env.example docker/.env` and `./docker/start.sh`, then confirm the service answers at http://localhost:8000. Report which backend was selected and the status of the running containers. Verify that the playground loads at http://localhost:8000 before reporting success.

  • Have the agent branch, commit and open a pull request

    Let the agent clone, branch, commit, push, and open or review a pull request with gh.

    View prompt
    In the omnirush-gui desktop app, open the repository at <repo-path>, create a branch named <branch-name>, make the change described in <task>, commit it, push, and open a pull request with gh. Report the pull request URL and confirm the push succeeded.

  • Turn a reference image into a flat or depth plane

    Convert an image into a flat plane or a dimensional plane for a scene.

    View prompt
    Using the OmooLab/AnyImage add-on in Blender, convert the Image Empty named <image empty name> into a Plane or Depth Plane. Expected output: a new plane object in the scene with the image applied. Verify that the plane shows the source image in the viewport.

  • Replay and export phone agent runs for analysis

    Review each step of an agent run and export screenshots and actions for another agent to analyze.

    View prompt
    Using the repo onehumanbeing/esp32-iphone-agent, take the exported trace from <run folder> and list every step where the taps or swipes did not change the screen. Expected output: a table of step number, action and whether the screen changed. Verify that each row matches a screenshot in the trace.

  • Find a Python function's docs by exact name

    Search the Python docs index and jump straight to the anchor for a named symbol.

    View prompt
    Use the only-cli/oc repo: run `oc py search <symbol>` with the target symbol name. Expect a numbered list of Python docs results, with an exact match linking to its anchor. Verify that the top result names the symbol you asked for before quoting it.

  • Swap models mid-chat from the LiquidGlass panel

    Change the model an agent uses during a conversation and confirm the switch with a verified hop receipt.

    View prompt
    Using the OnlyTerp/opengrok repo, run `python tools/glass-inject.py --check` and report whether the LiquidGlass HUD is present in the Grok Bot app. Then switch the active agent to <target-model> from the glass dropdown. Verify the VERIFIED HOP confirmation appears before reporting success.

  • Edit an agent-made film by hand in Studio

    Move, restyle, retime and retext any element of a film, then save named versions.

    View prompt
    In the openfilm/openfilm repo, run `openfilm open <folder>` to show an existing film in Studio. Make the edits listed in <edit list> by hand in Studio, then save a named version. Expect the film's files to reflect your edits, so the agent can keep them. Verify by reopening the film and confirming the changes are still present.

  • Build a personal agent that calls business agents

    Create a personal agent that signs requests and fetches a Brand's Agent Card.

    View prompt
    Using the openpactprotocol/openpactprotocol repo, write a personal agent client that fetches the Agent Card at <agent-card-url> with fetchAgentCard and sends one message with A2AClient. Output the source file and the Agent Card name returned. Verify that each outgoing request carries a signature produced by the signer.

  • Scan a branch for bugs and security issues before merging

    Get a P0 to P3 HTML scan that merges SAST, lint, and secrets results with a semantic pass.

    View prompt
    Use codexqa-defect-analyzer on this branch in <repo-path>. Merge SAST, lint, and secrets results with one semantic pass and write a P0 to P3 HTML report. Verify that each finding shows its location, evidence, and suggestion.

  • Review your change before you push it

    Run a review of unpushed commits and uncommitted work, then choose which findings to fix.

    View prompt
    In the repo at <path>, run `~/.openqodex/bin/openqodex review` and show me the receipt verdict and each finding line. Verify that the output ends with a report.html path or a 'Review incomplete' message with the missing stages named.

  • Compile your daily Pi extensions into Pi Bolt

    Turn installed extensions into machine code so they run without interpretation.

    View prompt
    In the repo opensec-git/Pi-Bolt, run pi-bolt compile on this Linux or macOS machine and report which extensions were compiled. Verify by running pi-bolt doctor and checking that the compiled extensions are listed.

  • Add phrase-routed tools to a C++ app

    Link the installed SDK into your own C++ program and register host tools with exact-phrase skills.

    View prompt
    Using the repo OpenSparX/MasterAgent, add MasterAgent::Core to <your app target> in CMake, register one tool and one exact-phrase skill from reference_runtime.h, and call Runtime::run() on a test phrase. Expected output is a typed tool result, not free text. Verify that an unknown tool name is rejected.

  • Run a local avatar demo on your own NVIDIA GPU

    Install the GPU service and open a local demo at localhost:7860.

    View prompt
    Use the openspline repo (github.com/openspline/openspline) to set up the local GPU service on <target-machine>. Run the install script and launch the demo, then confirm the demo answers at http://localhost:7860. Report the GPU model and whether the demo page loads.

  • Build and hot-reload a Vetta plugin outside the source repo

    Scaffold a plugin, install it into the running desktop app, and watch changes live.

    View prompt
    Using the Open Vetta plugin CLI from the open-vetta project, scaffold a plugin named <plugin-id> in <parent-directory>, then add a small capability declared in plugin.json. Report the output of `npx vetta-plugin-cli docs` and confirm the plugin installs with `npm run install:vetta`. Verify that the declared capability appears in plugin.json and is limited to what the task requires.

  • Self-host the Bops server on your Mac with your keys

    Run the Bops app and server locally, calling OpenAI and Orgo directly with keys you control.

    View prompt
    In the OrgoAI/bops repository, run `npm run setup`, then confirm that .env.local exists and that OPENAI_API_KEY, OPENAI_EXECUTOR_API_KEY and ORGO_API_KEY are set to <your-key-values> without printing the key values. Expected output is a running app started with `npm run app` on port 3210. Verify the server answers on port 3210 before reporting success.

  • Chat with a local model server through a relay endpoint

    Point Oriveo at Ollama, LM Studio, llama.cpp or vLLM on your own network and chat with local models.

    View prompt
    In the oriveo/oriveo repository, start a local model server, run the web client with npm run dev:app, and add a relay endpoint for the local server address <local-server-url>. Expected output: a reply from the local model in the chat. Verify that the request is sent to <local-server-url> and that no Oriveo account is requested.

  • Compare prices and stock across product pages

    Give Scout two or more products and get back a comparison of price and availability.

    View prompt
    Use the outcrawl/scout repo to build task.ts that finds <product A> and <product B> on <site URL> and compares their price and stock, then states which is cheaper. Print result.data and result.replayUrl. Verify that both prices in the answer match the replay before trusting the result.

  • Measure refusals and KL divergence against the original model

    Use Heretic's built-in evaluation to compare a decensored model with its original on the same metrics.

    View prompt
    Install the heretic-llm package from the p-e-w/heretic repo, then run `heretic --model <original-model-id> --evaluate-model <candidate-model-id>`. Return the refusal count and KL divergence the tool reports, and verify that both model IDs in the output match the ones you passed in.

  • Build a Cortico extension by talking to a coding agent

    Use the Cortina workspace and any coding agent to create or port a World extension.

    View prompt
    Open the Cortina workspace cloned from https://github.com/Pal-AI-Lab/Cortina and build a Cortico World extension that <goal>. Expected output: a package folder with a finished extension and npm publish steps. Verify that package.json includes the cortico-world keyword before publishing.

  • Drill LLM questions that recur across companies

    Practice the topics that come up at many companies, with the companies named for each.

    View prompt
    From the repo pallavi-shekhar/ai-engineering-interview-questions-company-wise, take the questions under the topic <topic> in the Common Questions section and list each with its companies and answer link. Expected output: a table with columns for question, companies and answer link. Verify that every company name in the table matches a company section in the README.

  • Run a local browser UI to generate and download parts

    Start the MAC web UI on your own machine to generate parts with a 3D preview and download results.

    View prompt
    Use the Multi-Agent-CAD repo (github.com/Pan-Chera/Multi-Agent-CAD). Start the web UI with python -m multi_agent_cad.web on 127.0.0.1, submit the brief <part description>, and confirm a downloadable result with a 3D preview appears.

  • Serve a governed record to AI agents with a refusal floor

    Provision a Postgres-backed serve path so agents query the record and abstain when it does not answer.

    View prompt
    In the panaversity/ksor repo, run `pnpm provision` once, then `pnpm refresh`, then `pnpm serve` in <project-directory>. Report the output of each command. Verify that an agent question on <topic> returns an answer that names its source document and publication, or an abstention when the record has no coverage.

  • Review Claude's replies and tool results together

    Walk a teammate through Claude's replies, tool cards, files and previews inside their own session.

    View prompt
    Using the Paradigm-Study/claude-share plugin, share the current session on the project at <project-path> and open /room to list the files Claude changed. Output that file list and the timeline of turns. Verify that the reviewer session at <reviewer-session> shows the same tool results.

  • Chart TTFT and queue depth on a live LLM service

    Connect Prometheus and Grafana to a vLLM server to watch latency and queueing.

    View prompt
    In the patchy631/time-to-first-token repo, set up the Prometheus and Grafana stack against a running vLLM server at <server URL>. Expected output: a Grafana dashboard with live TTFT and queue depth panels. Verify that the TTFT panel and the waiting-requests metric change after you send 20 test requests.

  • Pause at a suspect line and inspect its variables

    Set a line breakpoint, hit it, and read the object state the agent needs to test a hypothesis.

    View prompt
    Use the Debroid CLI to set a breakpoint in <class-name> at line <line-number> of the app <package-name>. Trigger <user-action>, then run `debroid pause-state --pretty` and `debroid inspect --max-depth=2`. Return the local variables and relevant object fields as JSON, and verify that the paused line matches the breakpoint you set.

  • Coordinate a group of bots on one goal

    Add several agents to one group conversation so they work toward a shared goal together.

    View prompt
    Using the Noodle repo at github.com/pdparchitect/noodle, set up a group of two bots to work toward <shared goal>. Expected output: a group containing both bots and a first shared message from each. Verify that each bot's backstory describes a different role.

  • Review an agent's changes and send notes back to it

    Mark up an agent's diff line by line and send the notes straight back to that agent.

    View prompt
    In the herdr-gpui app, open Review Changes for the worktree that <agent-session-name> is editing, leave one note on a changed line, and click Send to agent. Confirm the agent acknowledges the note in its session.

  • Point Claude Code at a local halogen server

    Serve the model on your own box and route Claude Code through the Messages API.

    View prompt
    Using the repo peonist-ai/halogen-flash-server, configure Claude Code on <target machine> to use the local halogen server on port 8731, following docs/claude-code.md. Expected output: a short Claude Code prompt returns a reply from the local model. Verify the server is listening on port 8731 before you test.

  • Monitor live Codex activity into a local record file

    Install a monitor-only Codex hook that writes events and findings to an NDJSON file.

    View prompt
    Use the repo perplexityai/numbat. Run `numbat hook install --agent codex --emit all` and then `numbat hook status --agent codex` on <target-machine>. Report the status output and the record_type values seen in ~/.numbat/records.ndjson after one short Codex task. Verify that the hook status output reports the Codex hook as installed, and remember that status checks configuration only, not delivery.

  • Point existing E2B Python SDK code at SPACE

    Use the E2B Compatibility Wrapper so E2B Python SDK scripts run on SPACE sandboxes.

    View prompt
    In the perplexityai/SPACE repo, follow docs/ecw.md to configure the E2B Compatibility Wrapper and create a compatibility API key. Run <path to E2B Python script> against it and report whether it completes. Verify that any call the guide lists as unsupported is not used by the script.

  • Trace why an approval was allowed or denied

    Rebuild each AI approval decision from the session log to check what the reviewer did.

    View prompt
    Using the repo PerryLink/dsh-auto-review, locate in the session log of <session-id> the approval/asked event for the request named <request-id>, then follow it to the autoReview/verdict or autoReview/rejection event and the approval/decided event. Report the decision, the reviewer reason, and the riskLevel. Verify that the final approval/decided outcome matches the verdict, and flag any mismatch.

  • Track policy and news for an industry in one timeline

    Search topics through the web tool and keep a deduplicated, dated timeline of public sources for an industry.

    View prompt
    With the dsh-industry-research plugin in DeepSeek Harness, call industry_track for the industry <industry-name> with a list of topics and a since date. Expect timeline.jsonl entries and a delta summary. Verify that each entry has an evidence category and that failed snapshots appear as citation-only entries with a note.

  • Verify a sealed report from its directory alone

    Recompute a report's seal and per-claim checks with the standalone verifier, without the original session.

    View prompt
    Use the dsh-research-verify CLI from the dsh-research-report repo on the sealed report at <report-dir>. Expected output: a JSON envelope or SARIF document that reports the recomputed seal hash and per-claim results. Verify that the recomputed seal hash matches the one recorded in manifest.json before reporting the report as intact.

  • Install the jev plugin into DeepSeek Harness from a checkout

    Add the jevcore-dsh package and its core dependency to a DSH profile and confirm it is active.

    View prompt
    Using the PerryLink/jevcore checkout at <absolute path>, add packages/dsh and packages/core to the DeepSeek Harness profile with the dsh plugin command. Expected output: the jev plugin listed as active. Verify that the log contains provider=mock and egress=OFF before reporting success.

  • Mark up a localhost page and send fixes back to the app source

    Review a running local page in the browser and have your agent apply the changes to the code.

    View prompt
    Using the petergyang/human-review skill, open the localhost page at <localhost-url> with /human-review. After I click Send, check that the agent changed the app source for each comment and report which files were edited.

  • Find the queries that eat the most database time

    Rank statements by total time or call count to pick the first query to tune.

    View prompt
    Use the pgbot tool from the pgrundev/pgbot repository to run `pgbot queries --json` against <target-db-url>. Return the top five statements by total time with their share and call count. Verify that the response has enabled true and available true before you report an empty list as a real empty workload.

  • Change one building detail as a reviewable code diff

    Adjust a shopfront or façade parameter in a world and confirm only that part changed.

    View prompt
    Using the repo PhiloLabs/fable51-worlds, find the shopfront recess depth setting in the kyoto-higashiyama code, change it by a stated amount, and list every file that changed. Expected output: a short diff with only the recess setting changed. Verify that no other world or module was modified.

  • Have Claude draft site changes over MCP for approval

    Connect Claude to your Kaleta site so it drafts pages, site parts and design changes you review before publishing.

    View prompt
    Using the kaletacms repository and its MCP support, ask Claude to convert the HTML in <source-file> into a draft page on my Kaleta site at <site-url>. Expected output: the draft's name and a list of changed elements, and confirm nothing is published until I approve it.

  • Get a specific work draft built from your answers, not guesses

    Answer a few questions so the rewrite contains your real example, number or outcome.

    View prompt
    Use the work-humanizer skill from the phuryn/work-humanizer repo in interview mode on <draft-file>. Ask up to five questions, then output the rewritten piece built only from my answers and the draft. Verify that the output contains no facts that appear in neither my answers nor the draft.

  • Count matching postings before pulling them

    Check how many postings match a search before spending your daily pull allowance.

    View prompt
    In the pinloop-cli repo, search Pinloop for <keywords and filters> and report only the number of matching postings, without pulling any. Expected output: one count per search tried. Verify that no postings were pulled by checking the plan usage before and after.

  • Turn a text prompt into an editable poster or chart

    Generate a poster or data visualization from natural language, then edit its text, colors, and layout directly.

    View prompt
    Using the Pinvou/pinvou-agent repo, launch the app and in Design mode ask the agent for a <poster or chart description>. Expected output: an editable design you can open in design mode. Verify that you can select an element and change its copy or color there.

  • Run a private artifact server on your laptop

    Start Artifact Server from source so one developer can store and review artifacts locally.

    View prompt
    Clone https://github.com/plannotator/artifact-server.git into a local folder, then run pnpm install and pnpm dev. Expected output: a printed local URL. Verify that the page loads in a browser on the same machine.

  • Draft a site HTML artifact from a live browser session

    Ask the side-panel agent to build a site HTML artifact based on what is open in your tab.

    View prompt
    Using the PawWork extension, select the content on <source page URL> in the side panel and request a site HTML artifact with a simple layout for that content. Verify that the artifact includes every heading and paragraph you selected.

  • Find existing rule violations before they spread

    List current violations by contract and rule in a repo right after setup, without changing code.

    View prompt
    In the repo at <repo-path>, after `/gap-trap setup` has finished, answer yes to the framework check. Return the existing violations grouped by contract and rule. Verify that no files changed by running `git status` before and after.

  • Test cart edge cases by editing live state

    Set state values in a running app to reproduce edge cases that are hard to build in automated tests.

    View prompt
    Using the medula MCP tools from the medula repo, connect to the running dev server for <app-port> and set the cart quantity to <quantity>. Expected output: the cart state after the change and the total it produces. Verify that the total shown in the browser tab matches the value the agent reports.

  • Review agent code changes and diffs in a browser

    Open the files and diffs a coding agent changed in Herdr, then review them with annotations in the browser.

    View prompt
    Using the powerfooI/roamgate README, open the Herdr workspace <workspace name> in Roamgate and list the files with code changes. Report each changed file path and whether a diff annotation was added. Verify the list matches the changes shown in the Herdr workspace before finishing.

  • Measure your own machine's speed with janas-bench

    Run janas-bench on your hardware to get tokens-per-second figures and a report for the project.

    View prompt
    In the janas repo at <install-folder>, run janas-bench --prompt 1024 --gen 16 and then janas-bench --rounds 3. Output the reading and writing tokens-per-second figures for each run. Verify that both runs completed and that the figures are reported as numbers, not errors.

  • Route simple and hard tasks to different models

    Use a typed Choice decision to pick a cheap or strong model, with a fallback for low confidence.

    View prompt
    Using the Promethe-us/awesome-jev README and docs/HANDS_ON.md, draft a routing function for <my task type> that sends each request to a cheap or strong model using a Jev Choice decision. Return the code and the confidence threshold you chose, then verify on a labeled set that escalation happens on hard cases.

  • Turn a vague request into an agent task card

    Use Chapter 3 and Lab 002 to define goal, constraints, acceptance, and stop conditions.

    View prompt
    In the Prysai-LLM-Playbook repository, follow book/chapters/03-task-protocol-EN.md and Lab 002 to convert <request> into a task protocol. The expected output includes goal, context, constraints, acceptance, stop conditions, and failure handling. Verify that the acceptance check can be run without asking the agent for judgment.

  • Add the Vision HOPE operator to your own vision network

    Use the standalone SRNL, VisionHOPEOperator, or VisionHOPEBlock modules inside a different PyTorch architecture.

    View prompt
    Using the VisionHOPE repo (PSRben/VisionHOPE), insert VisionHOPEBlock into <target model file> in place of its existing mixing layer, keeping input and output shapes as [batch, channels, height, width]. Run one training step on a random CUDA tensor and report the output shape and loss. Verify that the backward pass completes without error.

  • Compare answers from different AI models on one prompt

    Send the same question to several models by switching the model in one click and keep the best answer.

    View prompt
    Using the Ptero repo (Ptero-ai/Ptero), open https://ptero.pro and send the identical prompt <your prompt> to the models <model A> and <model B>, switching with the model dropdown. Expected output: two replies, each labeled by the model used. Verify that the model selector changed before the second reply was requested.

  • Set up agent coordination in an existing repo

    Run Pullboard init in a git repo so a coordinator agent can take your requirements and fan out work.

    View prompt
    In the git repo <path>, run `pullboard init`, then commit the files it wrote with `git add -A && git commit -m "chore(repo): set up pullboard"`. Report the files created and confirm that SPEC.md and DOCTRINE.md exist at the repo root.

  • Add a remote MCP server to Cursor with mcp.json

    Point Cursor at a hosted MCP URL by editing one JSON config file.

    View prompt
    Using the repo awesome-remote-mcp-servers, add the server <server-name> with URL <server-url> to the mcpServers block of mcp.json, then reload the client. Expected output: the server shows as connected and one of its tools runs. Verify the URL matches the README entry exactly before saving.

  • Hand a code review to another DSCODE session

    Send a steering request to a second session on the same machine and read its reply back.

    View prompt
    Using the repo qiz029/dscode, list sessions with `dscode sessions`, send the review request for <file path> with `dscode send --steer`, and return the reply from `dscode read`. Verify that the reply names the file you asked about.

  • Get warned before a rate limit stops your coding

    Set notifications for limit thresholds and use the burn-rate forecast to plan the rest of a session.

    View prompt
    Using the Pulse app from https://github.com/qunqin24/Pulse, enable limit-threshold notifications for <service-name>. Confirm the threshold setting is saved and report the burn-rate forecast shown on that service's detailed card.

  • Draft a Figure 1 from your paper with FigureForge

    Generate a first Figure 1 draft in the browser, grounded in gallery figures, using your own API key.

    View prompt
    Open the FigureForge page of the repo at https://qwdwqfwq.github.io/topconf-paper-figure-gallery/forge for the paper <paper title and abstract>, pattern <pattern>, and mode <svg or bitmap>. Expected output: one downloaded Figure 1 draft file. Verify that every label and number in the draft matches the abstract before reporting success.

  • Keep a floating voice assistant on your desktop

    Run a desktop orb that listens for a wake word and handles tasks without opening a terminal.

    View prompt
    Use the repo QwenAudio/qwen-audio-agent to build the desktop app for <platform> and launch the floating voice orb. Report the build output path and whether the built-in Gateway starts. Verify the orb responds to the wake word before reporting success.

  • Compare a judge in shadow mode before trusting it

    Log what the judge would do without letting it change anything, then read the verdicts.

    View prompt
    Set up the mu coding agent (github.com/qybaihe/mu) in shadow mode by writing `{"modes": {"default": "shadow"}}` to ~/.mu/agent/mu.json, then run a small task with `mu` in <project path>. Expected output: a ledger of verdicts that changed no behavior. Verify with `mu ledger` that the entries show probabilities and timing.

  • Map every API endpoint from an OpenAPI document

    Generate an endpoints diagram grouped by resource, with methods, auth, and status codes.

    View prompt
    In the repo <repo path>, import the OpenAPI file at <openapi file> into docs/api.endpoints.json with vibeX and render docs/api.endpoints.html. Report the number of endpoints per resource. Verify that the count matches the number of paths and methods in the OpenAPI document.

  • Check which Claude account has room left before work

    Refresh per-account five-hour and weekly usage so you can choose the account with the most room.

    View prompt
    Using the Janus repo at RamitVishwakarma/Janus, describe how to refresh usage figures for all saved Claude Code accounts in Janus. Output a table of each account with its five-hour and weekly usage and whether each figure was fetched or cached. Verify that the figures for the signed-in account match Claude Code's own limits display.

  • Route speech, chat and TTS to different AI servers

    Point each of the three endpoints at a different OpenAI-compatible server using the custom preset.

    View prompt
    In the esp32-thinks repo, apply the custom preset with separate STT, chat and TTS endpoints for <provider-list>, then confirm the generated provider config lists three different base URLs. Verify by running a typed probe with python3 scripts/tts_probe.py /dev/ttyACM1 "hello?" and checking that a reply is produced.

  • Make minified JavaScript readable before auditing it

    Unpack bundles and rename minified identifiers so shipped JavaScript can be reviewed.

    View prompt
    Using the webcrack or wakaru entries from the Awesome-REA README, make the minified bundle at <path-to-bundle.js> readable and save the output to <output-folder>. Report the modules and any endpoints or API calls you find. Verify that the bundle's exported names still match the original file.

  • Calibrate a scan and measure distances in it

    Give one known real distance, then have your assistant measure between points in the scene.

    View prompt
    Using the openreality MCP tools on the scene <scene id>, calibrate with the known distance <distance in metres> between <point A> and <point B>, then measure <target measurement>. Verify that the result is reported in metres only after calibration succeeded, and flag it as relative otherwise.

  • Check each diagram claim against its cited lines

    Walk inferred and unresolved claims in the diagram and open their cited source beside it.

    View prompt
    In the repo <target-project>, open the MLView diagram <diagram-file>.mlview.json and list each inferred or unresolved claim with its cited file and line range. Expect a short review list. Verify that every listed quote points to a file that is marked unchanged.

  • Approve a teammate's request through a pop-up

    Let your agent ask you Approve or Deny for a teammate's request while you are away from it.

    View prompt
    In the reason-machines/reason-network repo, run `reason-network setup` to list configured agents and how their messages are handled, then have a teammate send a test with `--notify`. Expected output: an Approve or Deny pop-up on your screen and the chosen answer delivered back to your agent. Verify that the pop-up appears and that the answer is attributed to you.

  • Auto-act on confident answers and queue the rest

    Gate automated actions on answer_confidence so uncertain items go to a human reviewer.

    View prompt
    In the receptron/laya repo, add a function that calls Laya systemOne on <record-file> with a choice question over the actions in <action-list>, and applies the top action only when answer_confidence is at least 0.9, otherwise returning it for review. Expected output: an object with the action, its answer_confidence and a review flag. Verify that a record with a near-even probability split is marked for review.

  • Let an MCP-capable agent query a binary headlessly

    Expose the Recurse engine to an agent such as Claude Code through the standalone MCP stdio server.

    View prompt
    Connect to the recurse-mcp stdio server from the Recurse repo at <repo path>. Using the engine tools, list the functions in <target path>, pick the three largest, and report their start addresses and any cross-references. Verify each address against the function list before reporting.

  • Check what an edit breaks before calling it done

    Run the edit check to see blast radius, tests that reach the change and incompatible call sites.

    View prompt
    Use ripwire on the repo at <path>. After editing <symbol>, run the --edit-check flag on it and report the blast radius, the tests that reach it and any incompatible call sites. Verify each flagged site by compiling before you change anything.

  • Fix text and timing by clicking the element on screen

    Click a frame element in the preview to change its text, easing or position without hunting through code.

    View prompt
    In the Remocn Studio project at <project folder>, change the element selected as [Element #1] so that <describe the change>. Expect the scene source file to contain the new value and the preview to update. Verify that the edit appears in the scene's TSX file and in review.md.

  • Triage a support ticket from the command line

    Run one decision script on a ticket file without starting a server.

    View prompt
    In the rizzo-flow repo, write a JSON file at <path-to-ticket.json> with the ticket text as state and an is_urgent question, then run `uv run rizzo decide <path-to-ticket.json>`. Return the decision and its probability. Verify that the output is a typed answer and not free text.

  • Ask a local model questions about screenshots

    Attach a projector file so the local server can read pictures such as dashboards, without sending them to a cloud API.

    View prompt
    In the UnbiasedStrata repo at <repo-path>, start unbiased-strata with the projector at <mmproj-path> and report the server log line that confirms the projector loaded. Then send the image at <image-path> to /v1/chat/completions and report the reply.

  • Get reminders and a daily task digest on your phone

    Set up one-time or recurring reminders and push them to your devices.

    View prompt
    Using the rociiu/talorys app at <pages-dev-url>, enable push notifications in Settings > General and create a recurring reminder named <reminder-name> for <time>. Report the automation's next run time. Verify that the reminder appears in the Automations list and the notification center.

  • Catch a retrieval ranking regression before release

    Compare two retrieval systems query by query and fail a release check when one query gets worse.

    View prompt
    In the repo rohitg00/ai-engineering-from-scratch, run the retrieval-evaluation-lab project with --init into learning-artifacts/retrieval-evaluation-lab, then implement stages until the --all --strict grader passes. Expected output: a per-query delta report that lists the query whose most relevant evidence ranks lower. Verify that the grader reports all stages as passing.

  • Command a real SO-101 arm with a plain-English goal

    Give an SO-101 arm a goal from the terminal and let an LLM pick each joint call.

    View prompt
    Using the rokbenko/quackd repo, register an SO-101 arm over lerobot:real under the name <arm-name> with a rest pose, then run quackd run --goal "Wave to the camera with an extended arm". Report the list of calls the model made and whether the arm returned to rest. Verify that the arm is at its rest pose after the run before starting another goal.

  • Route low-confidence fields to a human reviewer

    Send fields below the confidence threshold to a Streamlit review screen and save the corrections.

    View prompt
    In the py-idp repo, run one document through the pipeline and find which fields fall below the confidence threshold. Use the Streamlit HITL review screen to correct them, then confirm the corrections are saved in storage. Report the list of corrected fields.

  • Build a missing app from a plain-language description

    Describe a recurring need to Rome and have it scaffold, build, and iterate on a Rome App in one conversation.

    View prompt
    Using the rome-os/rome instance at http://localhost:7663, describe <recurring-task> to Rome so it builds a Rome App for it. Expected output: an app with an app.yaml manifest and its source in git. Verify that the app still works after the browser is closed and the conversation ends.

  • Run parallel agent tasks in Git worktrees and review diffs

    Switch between linked Git worktrees and accept or revert agent changes file by file.

    View prompt
    Using the Grok App repo (https://github.com/RongleCat/grok-app), open <repo-path> as a project and start one agent session per linked Git worktree. Expected output: separate sessions with their own changes visible in the Git diff review. Verify that each session shows the worktree it was assigned to before accepting any edits.

  • Let a coding agent read and drive other terminal panes

    Install the Think Term skill so an agent can send input to and read output from other panes.

    View prompt
    In the RoversX/ThinkTerm repo, use `thinkterm cli get-text` to read the output of the pane labeled <pane label>, then summarize any failing test. Expected output: a short list of failing tests with file names. Verify that the summary matches the text returned by get-text before acting on it.

  • Check local Codex or Claude sessions for duplicate retries

    Inspect your own Codex or Claude Code session logs for duplicate records, retry amplification and token anomalies.

    View prompt
    Using the AgentMeasure repo, run `agentmeasure check --runtime claude` on this machine and report duplicate records, retry amplification and token anomalies, with any missing inputs listed separately. Verify that the report states which inputs were not found instead of marking them as passing.

  • Watch agent runs in a terminal console

    Open Ruflo's terminal UI to see workflows, swarms, cost and events without Claude Code.

    View prompt
    Using the repo ruvnet/ruflo, run `npx ruflo tui --plain` in <project path> and save the output to <output file>. Expected output: one text frame showing the Overview page. Verify that the file contains the page labels before you report it as captured.

  • Get cinematic video prompts from any chat AI

    Paste the SKILL.md file as custom instructions to get precise prompts without installing anything.

    View prompt
    Use the contents of SKILL.md from the repo Rylaispirit/cinematic-video-prompt-skill as your system instructions. Write one English video prompt for <target scene> for <target model>, in a code block, with a one-line explanation. Verify the reply uses the camera, lighting and style terms from the skill and does not combine conflicting lighting or weather.

  • Find keywords a competitor ranks for that you do not

    Compare a competitor's keyword footprint with your own Search Console queries to find gaps.

    View prompt
    Using the open-seo-mcp-skills competitor-gap skill through the Ryze MCP, list keywords that <competitor-domain> ranks for and <target-domain> does not. Return the gap list with the data source for each row, sorted by opportunity. Verify that your-site rankings come from Google Search Console before you call a keyword a gap.

  • Work through CTF challenges and security labs with an AI agent

    Use a local agent workspace to solve CTF and lab challenges with your chosen model.

    View prompt
    Clone https://github.com/S1N6H/pentest-harness, run `pnpm install && pnpm build`, then start the Web UI with `pnpm dsh web`. Open a session for the CTF challenge at <target> and confirm the session can be reopened after a restart. Report the session identifier and whether the replay restored.

  • Use Roqer's Studio tools from Claude Code

    Register Roqer's Studio MCP server so Claude Code can inspect and edit your place.

    View prompt
    Using the Roqer repo at <repo path>, register the robloxstudio MCP server with Claude Code using the README command, then ask Claude Code to list the top-level instances in the open place <place name>. Expected output: a list of instances from the Studio place returned through the MCP tools. Verify that the Roqer plugin is loaded in Studio before the call.

  • Find files by what they contain and open them on another screen

    Ask Atticus for a file by its topic and it searches inside your files and opens the match.

    View prompt
    Using the repo SaarthurR/atticus-mac, ask Atticus to find files about <topic> by their contents. Expected output: the best matching file opens on the other display. Verify that the opened file contains the topic named in the request.

  • Check the retrieval benchmark numbers yourself

    Regenerate the results table from committed evaluation files and compare BM25, dense, and hybrid retrieval.

    View prompt
    Clone salikhussain71-code/PAKGOV-RAG-project, run python app/eval/final_table.py, and write the regenerated results to evaluation/retrieval/FINAL_RESULTS.md. Report the R@5 and MRR values for BM25, Dense, and Hybrid RRF (k=60). Verify that the values match the committed metrics JSON files in evaluation/retrieval/ and flag any difference.

  • Score a Harness setup against a reference scorecard

    Compare your DeepSeek Harness setup with the handbook's Agent Harness Scorecard to find gaps.

    View prompt
    Using the sandbaseai/deepseek-harness-handbook repo, read the Agent Harness Scorecard and the Agent runtime map, then score my setup described as: <setup summary>. Output a table of scorecard items marked present, missing, or unknown, with the guide to read for each gap. Verify that you recorded the DSH version I give you.

  • Build a matching favicon and OG card set

    Generate one icon family with a shared style and derive all sizes from a master.

    View prompt
    In the Sateezg/codex-bridge plugin setup, generate a square master icon for <project-name> with codex-imagegen, then create favicon and OG card sizes from it. Report the list of output file paths. Verify that every file exists and that the set uses one palette.

  • Control the Mac hands-free with a wake phrase

    Enable the "Hey Jev" wake phrase so commands start by voice with no widget click.

    View prompt
    On this Mac, use the jev-use app with the wake phrase enabled in Settings, then say "Hey Jev, <command>" with the command in place of <command>. Expect the widget to appear and the command to run, then listening to return to background wake-word mode. Verify the outcome on screen and confirm the wake phrase is still active in Settings.

  • Run local environments in the explorer

    Start the explorer on your own Docker daemon using the all-local config.

    View prompt
    In the scaleapi/agentenv-framework repo, prepare <project folder> with an .agentenv/config.toml copied from .agentenv/config.example.toml, then run `agent-env up`. Report the address or message the explorer prints and whether it started. Verify that the Docker daemon is reachable before you start.

  • Sync SSH hosts and keys across devices, encrypted

    Deploy a sync Worker and D1 database in your own Cloudflare account so every device shares one encrypted vault.

    View prompt
    Read workers/sync/README.md in the scarletkc/Hatoba repo and list the deployment options and the exact connection steps for a first device and a second device. Verify that the output names the Worker URL, the setup token, and the master password, and that it does not invent any command not in the guide.

  • Have an agent repair Seiso findings in project docs

    Let a coding agent use Seiso diagnostics to fix most doc findings and rerun the check.

    View prompt
    In the repository at <repo path>, run `seiso check`, fix the findings the diagnostics give a direct fix for, and run `seiso check` again. Report how many findings remain and list each remaining one as a decision that needs a human. Verify that no fix changed a fact that appears on more than one page without updating the page that owns it.

  • Audit every permission check a session makes

    Use the gate panel and its drill-downs to see which tools were allowed, asked about or denied.

    View prompt
    Install the scasella/claude-flightdeck plugin in Claude Code 2.1.287 or later, open /flightdeck, focus the pane with ctrl+x tab, and open the file drill-down with f. Report the number of allowed, denied and pending checks shown in the gate panel, and confirm credentials appear masked.

  • Let a coding agent read and edit the open Blender scene

    Connect Claude Code, Codex or Cursor to the local scenario-blender MCP server.

    View prompt
    Using the scenario-labs/blender-plugin MCP server named scenario-blender at http://127.0.0.1:9876/mcp, read the open scene in Blender and list the objects named <object prefix>. Report the object list and the tools available. Verify that no paid generation is requested unless I confirm it.

  • Make seamless textures and 360 skyboxes for an engine

    Have an agent generate tileable PBR textures and equirectangular skyboxes sized for engine import.

    View prompt
    Using the scenario-labs/skills repo, generate a seamless <surface> texture with PBR maps and a 360 equirectangular skybox of <scene>. Save both to <output-folder>. Verify that the texture tiles without a visible seam when repeated.

  • Keep minutes local for meetings that cannot leave the room

    Transcribe and write minutes on your own computer with MeetCap's local model, with no key or account.

    View prompt
    Using the seacen/meetcap repository, set MeetCap to its local model and record the meeting <meeting name>. Expected output: a transcript and minutes saved on this computer. Verify that no network request carries meeting text by checking the setting shows the local model is selected.

  • Keep a metadata-only audit trail of agent calls

    Use the dashboard and audit logs to review what AI agents sent and received through the gateway.

    View prompt
    In the securetron-gh/aifw repo, start the gateway with `docker compose up -d` and send three test requests through it. Report how many transactions appear in the audit logs for <agent-name>, and verify each entry contains metadata and not full prompt text.

  • Run the CPU test suite on the Breeze integration

    Execute the tiny-model and tooling tests to confirm the integration code passes locally.

    View prompt
    In the repo Sentinel3252/Native-Breeze-TTS-2-Support-for-vLLM-Omni, run the project checks and the tests/core suite in a Python 3.12 environment. Report the pass and fail counts and whether they match the 35 core CPU tests and 18 client and packaging tests in the README.

  • Plan a trip with flights, stays and a doctor visit

    Have an agent check flights, stays and a doctor's free slot in one request.

    View prompt
    Using the awesome-iran-mcp servers mrbilit, jabama and paziresh24, find the cheapest flight from <origin> to <destination> on <date>, a stay under <budget> Toman per night for <number> nights, and a doctor with a free slot in <city>. Return one table with each option, its price in Toman and its time, and state which items you could not check.

  • Export a riso poster as a 2160 x 2160 PNG

    Ask Claude Code for a riso still image and export it as a native 2160 by 2160 PNG for print or posting.

    View prompt
    In the riso-windowseat repo, create a riso poster of <subject> with the riso-still skill and export it as a 2160 x 2160 PNG using tools/still.mjs. Expect a PNG and a PRINT.md in prints/. Verify the PNG is 2160 by 2160 pixels.

  • Review Codex file changes and commit them in focused batches

    Inspect staged and unstaged changes per file, then commit only the related files.

    View prompt
    For the repository sevensir888/codex-command-center, describe how to group the uncommitted changes in <project path> by task and stage one group at a time. Output the file list for each group. Verify that no unrelated file is staged before committing.

  • Guard prose an agent saves in Claude Code

    Install the plugin so each prose file the agent saves is scored and flagged for rewrite.

    View prompt
    Install the sloptrim plugin from https://github.com/seyedehsanhadi/sloptrim, then run `/sloptrim doctor` and report whether it prints four [OK] lines. Save one prose file and verify that it appears in `/sloptrim show`.

  • Rewrite a long Markdown or Word document in one command

    Use the hz command line tool to rewrite a whole article or .docx while keeping its structure.

    View prompt
    Using the sgaofen/humanizer-local-model repo, install the hz tool with pipx and run `hz <input-file> -o <output-file>` on the target document. Expected output: a rewritten file with structure preserved. Verify that the stderr report lists no lost or added numbers, or that each listed piece has been checked by hand.

  • Lock component styling with per-component contracts

    Let pages change some styles on a component while keeping its size, shape, and font fixed.

    View prompt
    Use the GitHub repo shadcn-ui/lint to add a no-restyle contract for <component-name> in <project-path>. Write the contract in the ESLint config, then run the lint command. Expected output: the contract allows the listed classes and reports the others. Verify that one disallowed class on <component-name> produces the custom message from the config.

  • Design a shader visually and export it as code

    Stack effects on the Shaders.com canvas, tune props live, and paste the exported component tree.

    View prompt
    Using the shader-effects-inc/shaders design editor at shaders.com, help me design an effect for <project-path> and export it for <framework>. Expected output: the exported component tree pasted into the matching component file. Verify that the framework import matches the project.

  • Trace which provider and policy handled a bad AI answer

    Look up a request ID to see the routing reason, policy verdict, and answering provider.

    View prompt
    In the ShadowSafin/Synapass repo, call GET /admin/v1/requests/<request_id>/explain with the admin key and summarize the routing reason and the answering provider. Verify that the summary names the same provider as the synapass.provider field in the original response.

  • Make a typed decision in Python without a server

    Call the Decider class in a script to score options for text or images.

    View prompt
    Using the Shanghua-Gao/RSI-Jev package, write a Python script that loads Decider with v6.1-vl-4b and calls decide() on each record in <input-file> with a noul question about <topic>. Output one line per record with the option probabilities. Verify that every record gets a result and that image inputs are passed only when present.

  • Run a phone task on a rented cloud phone

    Rent a cloud Android or iPhone by the session and let an agent work on it without owning a device.

    View prompt
    Using the phone-harness repo at https://github.com/ShawnPana/phone-harness, start a cloud phone, complete the task <task description>, and return the final screen text. Verify with `cloud ls` that the session is stopped before you report completion.

  • Set up and launch the local game with Codex

    Install the entry skill and let Codex clone, build, and start the game on your machine.

    View prompt
    Use the infinite-pokemon entry skill from the Shellishack/infinite-pokemon repo to set up and start the game on this machine. Report the local address the game is running at and whether the starting map became playable after Codex verification. Verify that http://127.0.0.1:8788 loads in a browser.

  • Run semantic analysis on existing PostgreSQL tables in place

    Attach a table you already run without copying its rows, then query it with JEV from the workspace.

    View prompt
    Use the jev4pg repository to attach the existing table <schema>.<table> to the workspace for tenant demo without copying rows, using the external PostgreSQL setup. Report the grants that were applied and confirm that a test SELECT through the workspace returns only rows visible to the runtime login.

  • Have an agent submit finished work to in_review for human sign-off

    An agent claims a task, does the work, and moves it to in_review while a human accepts it as done.

    View prompt
    Using the DSH-taskboard repo at https://github.com/shengsheng90/DSH-taskboard, have the Harness Agent claim the task <task-key> with the taskboard_* tools, complete the work, and move it to in_review. Report the task key and its status after submission. Verify that the agent did not set the task to done.

  • Stream your avatar in OBS with webcam tracking

    Drive the avatar with your face and voice on the Live page and add its stream URL to OBS.

    View prompt
    In the mesh-avatar-studio repository, start the dev server with npm run dev, then open the Live page for <project name>. Expect a Copy OBS URL result that loads in an OBS Browser Source. Verify that the stream view moves when the Live page tracking is active.

  • Verify live web findings with marker and control tests

    Check a scope, then let the agent confirm live findings with marker reflection and a negative control.

    View prompt
    Using the blitzstrike MCP server, call scope_check for target <authorized URL> with scope <written scope>, then run_engagement on that target. For each candidate, call strike_verify and report only the findings with a live verdict. Verify that no request was sent to a host outside the scope.

  • Catch print problems before the printer runs

    Run Nurb's printability rules on a part to find overhangs, thin walls, and floating islands early.

    View prompt
    Using the nurb repo (Shpigford/nurb), run the printability checks on the part <target part name> in this project. Expected output: a list of findings such as overhang or min_wall with coordinates. Verify by running `nurb inspect` and confirming each finding appears on a face.

  • Have an agent work a goal across many turns on a schedule

    Set up a long-running goal loop that works unattended and reports to your inbox.

    View prompt
    In the Sidiora-Labs/centra-gideon-agent console, create a goal loop for <goal> on <schedule> and report the loop name, its schedule, and its first status. Verify that the loop appears under running loops and scheduled jobs before you report it as set up.

  • Give an agent a compact brief of a code area

    Pull matching symbols, callers, callees, and routes into one budgeted context call.

    View prompt
    In the Hyperfide repository, run `hyperfide context` on <symbol or area> and summarize the matching symbols, callers, and callees. Then run `hyperfide changes` and list the affected symbols. Verify that any omitted items are reported as omitted, not silently dropped.

  • Build and test the paxd Paxeer X chain node

    Compile, lint and test the Go Paxeer X chain node (paxd) without changing directories.

    View prompt
    In the Sidiora-Labs/Paxeer-X-Network repo, run make paxeer-build, make paxeer-lint and make paxeer-test. Report the result of each target and list any failing test names. Verify that the Go version used is 1.25.6 as set in go.mod.

  • Put Free My TV on an LG TV through webOS Developer Mode

    Install the Free My TV app on an LG webOS TV using LG's own Developer Mode and the included Python scripts.

    View prompt
    In the free-my-tv repo, build the LG version with `python3 webos/build.py` and prepare the install for the LG TV at <TV_IP>. Expected output: a built webOS package and the install command ready to run, with the passphrase left for the user to type. Verify that webos/install.py exists and that the build finished without errors.

  • Recompute a published benchmark score from saved counts

    Rebuild a reported task score from its reference counts to check the number yourself.

    View prompt
    In the Simreal-MLBench repository, run `mleb grade examples/snapshot.json examples/result.json` and then `python scripts/verify_report.py`. Replace the example files with the saved reference counts for <target task> if you have them. Report the recomputed score and whether the verification script passed.

  • Set up Codex CLI with gateway models in the /model picker

    Configure Codex CLI to use a Responses API gateway and list extra gateway models in /model.

    View prompt
    In the repo Sinholms/setup-gateway, run `node bin/setup-gateway.mjs codex --base-url <GATEWAY_BASE_URL> --api-key <API_KEY> --model <MODEL_ID> --yes`. Expect config.toml and gateway-catalog.json to be written in the Codex config directory. Verify that config.toml sets wire_api to responses and that model_catalog_json points to an existing gateway-catalog.json.

  • Turn your notes or PDF into an explainer video

    Point Frametell at a document or slides and render a narrated video in a chosen style.

    View prompt
    Use the Frametell repo at sitor-ai/frametell after running pnpm install and pnpm build. Run node apps/cli/dist/cli.js run <file> --style warm-story --duration 60 --lang en to turn <file> into an explainer video. Expected output: a 1080p MP4 with subtitles; verify that the narration covers the main points of the source file.

  • Build a high-fidelity pet with the Qwen identity backend

    Prepare the heavier local Qwen editor and create a max-quality pet that keeps the subject's look.

    View prompt
    In the repo six-nut/PocketMen-with-you, run `pocketmen create` with --engine neural --backend qwen-image-edit-2511 --quality max using the references at <photo-1> and <photo-2>. Expected output: a pet.json and spritesheet.webp built from the Qwen backend. Verify that the run did not use the OpenAI API and that the atlas is 8 by 9 cells.

  • File documents into a knowledge base with Claude Code

    Initialize a workspace for Claude Code and process a document through the local skill.

    View prompt
    In the knowledge-base-kit repo, initialize a Claude backend workspace at <workspace-path>. Open it in Claude Code and use the local process_docs skill with the Claude backend on inbox/<file-name>. Show the proposed category and changed files and wait for review before filing. Verify that `python kb.py check --backend claude` passes.

  • Keep an overnight build going when one agent runs out of quota

    Arm a handover so a second vendor's agent continues the task from the exact commit.

    View prompt
    In the repo <repo-path>, arm the rotate-agent skill from Sno Station Skills so that the task in <task-file> hands over to the other vendor's agent when quota reaches the threshold. Output the handover brief and the commit to continue from. Verify that the receiving agent confirmed the brief before touching any file.

  • Get a code review from a different agent

    Ask one agent to review another agent's work, so the reviewer does not share its habits.

    View prompt
    In the sno-station repository, ask the <placeholder> agent to peer-review the latest changes made by the other agent. Expected output: a review written by the reviewer, not the author. Verify that the reviewer names the specific files and lines it checked.

  • Let Codex run browser-grounded social research

    Install the Jev Social skill into Codex so it can run cited social research for you.

    View prompt
    With the jev-social skill installed in Codex, research <goal> on <platform> using the local socai CLI. Expected output: a short evidence summary with captured source URLs. Verify that login-gated or failed steps are reported as partial results.

  • Preview the kitchen interface with scripted example steps

    Explore Agenttrail Kitchen with a labeled scripted example before connecting any real agent.

    View prompt
    In the repo <repo-path>, start Agenttrail Kitchen in example mode and advance through at least three example steps. Report which chef and ticket changed at each step. Verify that the view is labeled as scripted example activity and not as live observation.

  • Lock files so a coding agent cannot delete or edit them

    Put an OS-level lock on key files and start the agent inside that protection so it cannot remove them.

    View prompt
    Using the SolonGate repo at https://github.com/solongate/agent-security, run `solongate protect <file-path>` and then `solongate run -- claude` in <project-path>. Expected output: the protected file cannot be deleted or written by the agent. Verify by running `solongate protect list` and checking that <file-path> is listed with the lock it is actually held by.

  • Build a Linux AppImage of Maid Kit for a workstation

    Compile the Linux release bundle and pack it into a single portable MaidKit-x86_64.AppImage file.

    View prompt
    In the Solsynth/MaidKit repo, run `flutter build linux` and then `bash buildtools/build-appimage.sh`. Expected output: a file named MaidKit-x86_64.AppImage in the repo directory. Verify that the file exists and is non-empty before copying it to <target-machine>.

  • Compare REA agent setups before a reverse-engineering project

    Use the LeanREA benchmark and related cases to choose between CLI and MCP for a coding agent.

    View prompt
    Read the LeanREA case in the songshikang0111/awesome-REA-cases repo and summarize its CLI versus MCP comparison for <target task>. Output the reported scores, time, and cost, and state whether the result was independently rerun. Check that the limits (one model, one machine) are included in your summary.

  • Run the voice assistant fully offline with Ollama

    Use the local mode with Ollama and a local voice so no API or usage cost is needed.

    View prompt
    In the sosoj92/jarvis-assistant-vocal repo, configure local mode with Ollama and a local voice on this machine. Expected output: `python scripts/doctor.py` reports a recommended local model and Jarvis answers a spoken request with no cloud call. Verify that the mode shows as local before reporting success.

  • Bring an existing project up to the toolkit setup

    Diagnose a current codebase and add applicable agent configuration without breaking its stack.

    View prompt
    Read the repo soumatheusgomes/vibe-coding-toolkit at docs/prompts/12-existing-project-setup.md and execute the Prompt section in the project at <project path>, starting with brainstorming. Report the before and after state, the changes applied, and any pending work. Verify that existing stack, database, and contracts were preserved.

  • Clone, test and fix a repo on an agent's desktop

    Have an agent clone a project, run its tests and fix failures in an isolated desktop, then review the diff.

    View prompt
    Using the open-source repo SouravBeraAkaSpeed/xiryn, ask a Xiryn agent to clone <repo-url>, install its dependencies, run the test suite and fix the failing tests. Expected output: a diff of the changes made. Verify that the test command passes on the agent's workstation before accepting the diff.

  • Build a multi-part feature with parallel Codex work

    Run a larger feature build in Codex with Autoprompt starting ready, independent work in parallel.

    View prompt
    Using the Spielewoy/autoprompt-skill repo, run `autoprompt activate codex --target <absolute project path> -- --concurrency wide "<your feature goal>"`. Expected output: a built feature across the layers named in the goal and a summary of what changed. Verify that the project's tests pass after the run.

  • Check a retargeted clip against its source video

    Render a side-by-side review and measure limb, head and foot errors against the plate.

    View prompt
    In the squall01337/mixamo-llm-mocap repo, run render_review.py and eval_fidelity.py on the clip at <clip folder> using its spec <spec path>. Expected output: a review video and a fidelity report with limb and head angles, foot slide and jitter. Verify the report lists foot slide and jitter values for the clip before you call it done.

  • Find open-access papers and add them to your library

    Search OpenAlex and arXiv in one pool, preview records, and add the useful ones to your Thesys library.

    View prompt
    Use the Sreehari05055/thesys-core repo to start the Docker workspace, search Discover for <your topic>, and add the five most relevant open-access papers to the library. Report the titles and links of the papers added. Verify that each added paper appears in the library list.

  • Get a system banner when Claude Code needs input

    Receive a macOS notification banner with sound when a session needs you, even in fullscreen apps.

    View prompt
    In the clawd-conduit repo, confirm that ~/.claude/hooks/ contains the notification script after running `bash install.sh`. Report the file listing and state whether the Notification hook is attached in ~/.claude/settings.json.

  • Package the Starling desktop as a Debian package

    Stage the desktop and build a .deb that adds a Starling session to the login screen.

    View prompt
    In the starling repo, build the shell and apps with swift build -c release, then run build/stage.sh and build/package-desktop.sh. Expected output: a starling-desktop_ _amd64.deb file in the output directory. Verify that the package installs files under /usr/lib/starling and /usr/share/starling before reporting success.

  • Test decision requests on the hosted 27B model without a GPU

    Send decision requests to the hosted 27B AutoThink model with a Bamboo API key.

    View prompt
    Using the StartLux-Decision README, build a POST request to /v1/decisions on bamboonode.dev with the state <state_text> and one choice question with the criteria <criteria_list>. Return the response answers and the model name. Verify that the model name in the response is the 27B AutoThink model.

  • Undo an agent turn that broke your files

    Restore project files to the snapshot taken before an agent's last turn, in one click.

    View prompt
    Using the Tellurion repo at https://github.com/steventsvik/Tellurion, run an agent turn in <project-folder> that makes a change, then use Undo last turn from the tab's ⋮ menu. Report the list of files the undo listed. Verify that the restored files match their state before the turn.

  • Build research Projects from saved web and YouTube sources

    Save selected text and video summaries to Knowledge, group them into Projects, and synthesize them.

    View prompt
    Using the Superpower repo at https://github.com/stloendays/Superpower, save the selected sources on <topic page URLs> to Knowledge, add them to a Project named <project name>, and export the Project as Markdown. Expected output: one Markdown file that lists each source with its title and URL. Verify that every source in the file has a URL and a timestamp.

  • Keep API keys away from an agent with credential injection

    Let the egress gateway add API credentials to permitted requests so the agent never sees them.

    View prompt
    In the strands-agents/box repository, read docs/user/security.md and docs/user/policy.md, then configure credential injection for <api-host> in box.toml and policy.dw. Expected output: a permitted request to <api-host> succeeds and the agent's environment does not contain the API key. Verify that a request to a host not in a permit rule is denied.

  • Flag messages that convey urgency

    Get a yes or no urgency check on each message from a single command.

    View prompt
    Using the strands-decider repo, run the ask command with --state set to <message text> and --noul set to "Does this convey urgency?". Return the noul value. Verify that the value is between 0 and 1 and that a clearly urgent test message scores higher than a routine one.

  • Make a vertical 9:16 product teaser for social

    Generate a 1080 x 1920 HyperFrames teaser for a product launch from a short brief.

    View prompt
    In the hyperframes-motion-reel-skill repo, run /hyperframes-motion-reel with the brief <product description>, vertical 9:16. Expected output: a 1080 x 1920 MP4 teaser rendered at 60 FPS. Verify the frame size with ffprobe on the final file.

  • Serve Qwen3.5-9B through vLLM with Glyd quantization

    Start a vLLM server for Qwen3.5-9B using the glyd quantization option.

    View prompt
    In the repo surya-koritala/Glyd, install the vLLM extra with `pip install "glyd[vllm]"` on a machine with <GPU model>, then start `vllm serve Qwen/Qwen3.5-9B --quantization glyd`. Report the weight memory vLLM logs and compare it with the bf16 figure of 17.66 GiB in the README. Verify that a test request to the server returns a completion.

  • Receive a ranked weekly digest of new job openings

    Get one Monday email listing the week's new postings across all tracked companies, sorted by resume fit.

    View prompt
    In the jobradar repo, run ./run.sh scan and then ./run.sh digest, and report how many new openings were scored and whether the digest email was sent. Verify that the digest email arrives and lists postings sorted by score.

  • Compare country coverage and delivery rates before ordering

    Check how many countries and how many live numbers exist before spending balance.

    View prompt
    Using the sv-number/mcp-server tools, call list_countries and report the number of rows, then call list_services for <site name> and compare deliveredPercent and online across the top matches. Expected output: a table of country and service options with price, online and deliveredPercent. Verify that every figure comes from a tool response and not from memory.

  • Give Claude Code live New York event search

    Register SyncSo as an HTTP MCP server in Claude Code with one command, then query it from the terminal.

    View prompt
    In Claude Code, with the SyncSo MCP server from SyncSo-Inc/syncso connected, search for live music events in New York on <date> and list the top three with time, price, and booking link. Verify each result by calling get_details on it before you report it.

  • Let games take the GPU while you play and resume AI after

    Berth drains AI engines when a supported game launches and returns the card when you quit.

    View prompt
    On the machine with the Berth repo, run `berth service install --harbor` and then `berth status`. Expected output: the card and any leases are listed. Verify by launching a supported game and confirming `berth status` shows the game as the holder while AI engines are drained.

  • Hand off an AI task with its context to a colleague

    Freeze the needed context and files so a teammate can continue the work in their own task.

    View prompt
    Read the README at <repo-path>/README.md, section 工作可以交接, and list what a task continuation carries and what stays local to each person. Report any item that the README does not state, and do not claim features beyond it.

  • Have an AI agent mesh and solve a beam over MCP

    Connect Claude Code to FieldCraft so it opens a part, meshes, solves and checks tip deflection.

    View prompt
    Using the FieldCraft repo at tangency-labs/fieldcraft, connect to its MCP server with `fieldcraft-cli mcp`, open the I-beam part at <part-path>, hex mesh it, apply a clamp and a 1000 N tip load, and solve. Report the tip deflection in mm and the beam theory value with shear, and verify the two values agree within a small tolerance before answering.

  • Locate products and read on-screen text in frames

    Find products in live-stream frames and read the text shown on screen, using the image tasks TLive Omni covers.

    View prompt
    Using the TLive-Omni repo at https://github.com/TaoLiveAIGC/TLive-Omni, find the products visible in the frames at <path to frame folder> and return each product's location and any on-screen text as a table. Verify by checking three frames by eye against the table before reporting.

  • Run Claude Code against the free model pool

    Configure Claude Code to send its requests to the local router instead of a paid Anthropic account.

    View prompt
    In the freellmapi repo (tashfeenahmed/freellmapi), run the setup-claude command against http://localhost:3001 with the unified key from the Keys page, then start Claude Code in <project-path>. Expected output: Claude Code answers a small coding question. Verify that the router dashboard shows the request and that the Claude Code config file was backed up before the merge.

  • Attach local files to project tasks for AI work

    Put your existing documents in the library and reference them from project tasks.

    View prompt
    Using the WorkDSH repo at techflag/workdsh, add the local files in <folder path> to the library and reference them from a project task. Expected output: a task that lists the referenced files and their revision. Verify that the task still points to the same revision after you edit a file.

  • Have Claude Code build a web app from your phone

    Describe a web app in chat and let Claude Code write it inside the Linux subsystem.

    View prompt
    In Mobile Harness on an ARM64 Android phone, open a new project in the AI Workspace with Claude Code and ask it to create a small Vite web page. Expected output: project files in the workspace and a running local preview. Verify that the preview loads and the files appear in the project.

  • Check an AI motion video against the mog gates

    Run the render checks and page-chrome lint on an AI-made video to see which tells it fails.

    View prompt
    Using the motionmaxxing skill from Tejashmakwana/motionmaxxing, run look.py and lint.mjs on <path to video and HTML source>. Report each gate G0 to G5 with its number and pass or fail, and say which two gates need a human look. Verify that every number in the report came from a script output.

  • Create speech from a voice description alone

    Generate a spoken line from a text description of the voice, with no reference audio needed.

    View prompt
    In the Tencent-Hunyuan/AuK repo, use auk-infer with only an --instruction that describes the voice and contains <target text>, and write the result to <out.wav>. Verify that <out.wav> is created and that its length is close to the requested seconds.

  • Build an assistant that remembers users across sessions

    Keep strong memory and a user profile that persist across sessions and can be saved on request.

    View prompt
    In the TencentCloud/octop-harness repo, set up a workspace at <workspace path> and add the user preference <preference> to USER.md. Start a new session and ask <question>. Verify the reply uses the saved preference.

  • Continue polishing an existing Vibe Game project

    Point the agent team at a game you already built and direct its next round of edits.

    View prompt
    Using the VibeGame repo at https://github.com/tettethu/VibeGame, run vibegame start --project ./<project-folder> with the request "<change request>". Expected output is an updated game in <project-folder> with the requested change applied. Verify by running vibegame run --port auto and checking that the changed behavior appears in the browser.

  • Find past decisions and bug fixes before you repeat them

    Use the mem-search tools to look up earlier bugfixes and decisions, then fetch only the relevant details.

    View prompt
    Using the claude-mem MCP tools, search memory for <topic> in the project at <project path>, then use timeline on the most relevant result and get_observations with the chosen IDs in one batch. Report a short list of decisions or fixes with their IDs. Verify that every ID you report came from the search results.

  • Assign agent work with approvals and watchdog checks

    Create projects and tasks for agents, with human approvals and a watchdog that verifies done work.

    View prompt
    Using the repo theNetworkChuck/paperclip-guide, follow chapters 6 and 7 to create one project in Paperclip with a test task for <agent name>. Report the task status, any approval requests, and the Watchdog's verdict. Verify that the task cannot be closed without the required approval.

  • Edit RAW photos in a free desktop app

    Install a free RAW editor with masks and AI tools and skip the subscription.

    View prompt
    Using the repo thesnarkitecht/rembrandt, download the installer for <platform> from the project's Releases page and confirm the file's SHA-256 matches the published checksum. Report the file name and whether the checksum matched.

  • Prototype data dashboards that answer questions with charts and tables

    Open the dev-only gallery to see two dashboards over demo data, then adapt them to your own data.

    View prompt
    In the thesysdev/open-intelligent-ui repo, read src/lib/demo-data.ts and src/app/gallery/tool-programs.ts. Summarize how get_orders feeds a dashboard, and name the Chart types and @functions (such as @GroupBy or @Pivot) the dashboard uses. Verify by opening /gallery after npm run dev.

  • Add streamed OpenUI rendering to a React app

    Install the React runtime and prebuilt chat UI to render model output in an existing app.

    View prompt
    In the thesysdev/openui repo, use the @openuidev/react-lang and @openuidev/react-ui packages to add a streamed chat panel to the React project at <target project path>. Expected output is a running chat view that renders OpenUI Lang output; verify by sending one test prompt and confirming a component renders rather than raw text.

  • Hand single decisions to a System 1 agent from Claude Code

    Install the s1a skill so Claude Code or Codex sends one-off choices to a fast model.

    View prompt
    Using the system1-agents skill in this session, decide the best option for <task-description> with the s1a decide command. Report the chosen option, its probability and the command you ran. Verify that the reported choice is one of the options you supplied.

  • Get engine and fault events posted to the family room

    The car posts engine reads and stored fault codes into a chat room when real events happen.

    View prompt
    Using the CarWatch repo at https://github.com/ThinkOffApp/CarWatch, configure the room agent for the GroupMind room <room-name>, then report the last three event posts it made. Verify that each post has a timestamp and that no post appears without a real car event.

  • Hide API keys from a relay before requests leave your machine

    Replace secrets in requests with placeholders so a relay never receives the real key or private data.

    View prompt
    Using the repo ThinkWatchProject/ThinkWatch-Lite, enable the secrets and privacy protection and route a test request containing the dummy value <dummy key> through the relay <relay name>. Expected output: the relay-side request shows a placeholder instead of the dummy key. Verify this in the request history of the gateway.

  • Grade a suspicious submission with evidence, not guesses

    Run paper-slop-screen to get W/R/Q grades, a quadrant, located findings, and a note to the AC.

    View prompt
    Use the absent-author repo's paper-slop-screen skill to triage <paper PDF or folder>. Return the W/R/Q grades, the quadrant, and each finding with its location and quote. Verify one finding by opening the cited location yourself before you rely on it.

  • Inspect the Pokémon harness archive locally

    Run the bundled Pokémon example viewer to review decisions without making any model requests.

    View prompt
    Clone https://github.com/TianyuCodings/JevHarness, build and preview the website with Node.js on port 8768, then report the number of archived Eval games shown on the page. Expected output: the viewer loads at localhost:8768. Verify that browsing makes no model requests and starts no games.

  • Recover why a past decision was made and what it said then

    Pull the reasoning behind an old choice and check what the memory said on a given date.

    View prompt
    Use the agent-memory repo at <store path> to find the memory about <decision topic>, then show its outline and the version valid on <date>. Expected output: the memory path, its outline, and the as-of answer. Verify that the as-of answer differs from the current file when the memory was superseded.

  • Turn red SEO items into a P0, P1, P2 fix list

    Have the agent explain each failed check and rank the fixes so the team knows what to do first.

    View prompt
    Using the tigerless-labs/seo-ops skill, run the check on <target-url> and group every red item into P0, P1, and P2. For each item, give the fix and point to the evidence in the report. Verify that every red item appears exactly once in the priority list.

  • Ask for an app change in chat and get it shipped

    Describe a small fix or feature in chat and let the Claude Code loop ship it to your devices.

    View prompt
    In the TimeLovercc/mojito repo, pick up open feedback from the hub, decide whether it is auto-ship or ask, and apply the change for <feedback-id> in the private copy. Expected output: a one-line plan, a passing typecheck and build, and a summary sent to the hub. Verify the change appears in the app after the build.

  • Route requests with NeoHorse-Jev structured decisions

    Use NeoHorse-Jev-4B to pick an action, check a condition, or assign a rating from app state.

    View prompt
    In the TokenRhythm/NeoHorse repo, read the NeoHorse-Jev deployment guide in jev/README.md and set up the model bundle at <model-directory>. Send the application state <sample-state> with the Choice question <question> and report the selected answer and its probability. Verify that the probabilities for the listed answers sum to a value you can explain.

  • Resume an interrupted coding task with its context

    Return to an earlier Eido task with its conversation and review context intact.

    View prompt
    Using the Eido repo (tony3liu/eido), reopen the earlier task named <task-name> in the project at <project-folder> and ask the agent to continue the unfinished step. Expected output: a short summary of the prior work and the next proposed changes. Verify that the summary matches the earlier conversation before accepting any change.

  • Save a team once and reuse it across projects

    Define a planner, implementer, and reviewer with their own models, then select the team per conversation or per project.

    View prompt
    Using the dsh-agent-team-gui repo, create a team named <team-name> in Settings → Teams with a planner, an implementer, and a reviewer, each with its own model route. Report the saved member list and the activation settings. Verify that the team still appears after a page refresh.

  • Transcribe an audio or video file by dragging it to the notch

    Drop a recording on the notch to get a transcript saved next to the source file.

    View prompt
    In the repo tornikegomareli/Talkify, read the Drop a file on the notch section and list the steps to get a transcript of a file at <path to audio or video file>. Output the steps and the default save behavior, and verify that the README says the file is saved after five seconds unless the island is hovered.

  • Split independent jobs across parallel workers

    Send separate jobs to CoS workers at once and bring their results back into one ChatGPT conversation.

    View prompt
    Using the repo totec448-spec/chat-on-steroids, split these independent jobs across workers: <job-list>. Expected output: one result per job, each attributed to the worker that ran it. Verify that every job has a result and that no worker reports work on a job it was not given.

  • Get a physical cue when Claude Code needs approval

    Feel a repeating pattern while a permission prompt waits, so you can step away from the screen.

    View prompt
    Use the transkatgirl/vibeclaude plugin in Claude Code with <device name> selected in Intiface Central. Start a task that needs a permission prompt and confirm that the device pulses three times at a steady pause until the prompt is answered. Report which tool asked for permission and whether the pattern stopped when the tool finished.

  • Solve ML coding questions in the browser with instant grading

    Answer topic-based ML questions in Pyodide with no local install and get graded instantly.

    View prompt
    Open trentorch.com, sign in, start one question from the Inference track, and report the question title, whether the grader returned pass or fail, and the first failing test name if any.

  • Script agent sessions with the TrueForge TypeScript SDK

    Drive agent sessions and turns from your own TypeScript code using the HTTP API and SDK.

    View prompt
    In the truefoundry/trueforge repo, use the TypeScript SDK @truefoundry/trueforge-sdk to create a session against a running local TrueForge instance and send one turn asking for <task>. Output the final answer and the session ID. Verify that the same session appears in the Sessions view with its turns and tool calls.

  • Host isolated email for each customer on one deployment

    Stand up one Sentio deployment and mint separate tenants and API keys for each customer.

    View prompt
    Using the truespar/sentio repo running on localhost:8080, rotate the bootstrap admin key and create a tenant for <customer-name> with its own API key. Report the new tenant ID and confirm that GET /v1/tenants lists it. Verify that the bootstrap key no longer authenticates.

  • Have an agent fill contact gaps from your own email threads

    Run the research agent so it reads your CRM's threads, meetings and signature blocks and records strong facts.

    View prompt
    In the trycompai/crm repo, use the apps/agent research agent to run read_crm_history and record_fact for the contact <contact-name>, with no outside API keys set. Report the facts recorded and any suggestions left for a human. Verify that every recorded fact cites an observed source such as a signature block or thread.

  • Review a GitHub PR or GitLab MR in a local terminal view

    Open a pull or merge request in Reslop to read its changes and leave findings before you merge.

    View prompt
    Using reslop in the repository at <repo-path>, open the pull request at <PR-URL> and list every finding saved to the newest .plan/ file. Report the count of findings and the file path. Verify that each finding names a file and line from the PR diff.

  • Decide if readiness flags are duplicate state

    Check whether several readiness flags express distinct lifecycle guarantees or just repeat the same state.

    View prompt
    Use $simplify-codebase in Focused Survey mode on <subsystem path> to decide whether the readiness flags <flag names> express different lifecycle guarantees or repeated state. Do not modify files. Expected output: one verdict per flag with its consumers and lifecycle owner. Verify that each verdict cites the readers and writers it traced.

  • Resume a repo in a new session from one handoff page

    Start a new Codex or Claude Code session from the repo's handoff instead of old chat logs.

    View prompt
    In the repo at <repo-path>, read docs/ai/project-card.md and docs/ai/handoff.md only, then search WARM files for <topic> with rg. Expected output: a three-line summary of the current task, the next step from handoff.md, and the file and section used. Verify that no COLD file under history/ was read unless I ask for it.

  • Pick a visual theme for a tone and audience

    Get a shortlist of gallery themes that fit a tone and audience, skipping recent ones.

    View prompt
    Use the saas-motion-kit repo. Run `python tools/pick_themes.py --tone <tone> --audience "<audience>" --history ~/.motion-ledger.json` for the film about <product name>. Expected output: a shortlist of theme ids that skips your last five films. Verify that none of the shortlisted ids appear in the history file.

  • Route support tickets to the right team with fixed choices

    Assign each incoming ticket to one team from a fixed list, with a description for each choice.

    View prompt
    In the TypeLLM/TypeLLM repo, call TypeLLMClient.generate() on each ticket in <tickets_file> with a queue field whose choices are billing, technical, shipping and other, each with a description. Return a list of ticket IDs with their queue. Verify that every queue value is one of the four choices.

  • Find b-roll clips in a library by plain-text search

    Generate sidecars once, then grep .cdaf files to pick cut candidates by description.

    View prompt
    Using the CDAF format from the repo UditAkhourii/cdaf, search every .cdaf file in <footage-folder> for the description <shot-description>, and return each matching clip path with its matching segment timestamps. Verify that each returned sidecar reports FRESH before you use it.

  • Review a planned design in Codex against arXiv prior art

    Install NeuroArxiv for Codex CLI and have it check a planned system design before implementation.

    View prompt
    Use the NeuroArxiv skill from the UditAkhourii/neuroarxiv repo on this problem: <your design problem>. Before writing code, return the recommended approach, the cited arXiv papers, the first step, and the pitfalls from each paper's limitations. Check that every paper id is a real arXiv id before you use it.

  • Find the real failures in a long log without reading every line

    Have Jev mark which log lines report a failure, then pass Claude the collapsed result.

    View prompt
    Using the repo UditAkhourii/quicksilver, run qs filter with the question "Does this line report a failure?" and the --lines flag on <log-file>. Summarize the matched line ranges and their likely causes. Verify that the receipt line reports the number of lines scanned.

  • Ask an AI chat questions about an Unreal level

    Use the built-in chat to query a level, such as counting lights, without writing code.

    View prompt
    Using the ueboxai/uebox app with an open Unreal project, ask the AI chat how many light actors are in the current level and return the number. Verify the answer by checking that the tool call list shows a level query, not a guessed number.

  • Hand a task to an agent in a hosted sandbox

    Give an agent a task from the terminal that keeps running in a sandbox after the client exits.

    View prompt
    Use the ufo client from the ufo-core repo to send the task <task description> with `ufo --remote`. Expected output: a turn ID and a sandbox result under /workspace. Verify the turn ID by running the resume command before you report the result.

  • Review each PR as it opens, worst findings first

    A reviewer agent reads each new PR, splits large ones across helpers, and lists findings worst first.

    View prompt
    Using the Overtime repo at ukanwat/overtime, create a reviewer agent that reviews each new PR in <target repo>. Expected output: a findings list ordered worst first for one open PR. Verify that large diffs were split across helpers and that every finding names a file.

  • Run a project through an Inputs, Process, Outputs pipeline

    Give one project its own CLAUDE.md and a four-stage folder pipeline the agent follows.

    View prompt
    In the second-brain-os vault at ~/brain, work inside the <project-folder> project using its CLAUDE.md and its Inputs, Process, Outputs and Feedback folders. Produce the project's output file and note what changed in Feedback. Verify that the output cites at least two existing wiki pages.

  • Run a coding agent from the terminal TUI

    Start the cozy TUI and give the agent a local task that uses Bash or image viewing.

    View prompt
    In the unreal-agent repo at <repo path>, build cmd/unreal-agent-tui and start a session. Give the agent the task <small local task>. Expected output: the agent's answer plus the recorded tool calls in the session. Verify that every tool call shown in the history matches an action you approved.

  • Install the Rune IDE on macOS or Linux

    Install the latest Rune release with one command, or with Homebrew, and let it update itself.

    View prompt
    For the repo unstablebuild/rune, install the latest release on this macOS or Linux machine using the install command in its README, then report the installed version. Verify the install by confirming the rune command runs.

  • Self-host the agent workspace on your own Linux server

    Run UseAgent on your own Linux host so code, prompts and files stay where you put them.

    View prompt
    In the useagent repository, read infra/self-host/README.md, then deploy UseAgent to the server at <server-ip> using infra/self-host/deploy-app.sh. Expected output: a running UseAgent app on that server plus a short note of the sandbox plugin chosen. Verify that a test thread completes and its steps are stored in Postgres.

  • Split a feature across child agents in separate worktrees

    Delegate parallel pieces to child agents, each bound to its own worktree and branch.

    View prompt
    In the repo at <repo-path>, use p3-stack's orchestrate playbook to split <feature description> into independent parts, one worktree per part via t3_thread_launch. Expected output: one branch per part and a short summary per branch. Verify that no two workers share a worktree.

  • Generate and edit images with GPT or Grok

    Have a DSH agent create or edit images through the image_generate tool using a ChatGPT or Grok subscription.

    View prompt
    Using the dsh-plugin-subscriptions repo, call the image_generate tool with the prompt <prompt> and provider set to gpt or grok. Expected output: one or more image file paths under ~/.dsh/plugins/subscriptions/images/ shown inline in the conversation. Verify that the file exists and matches the requested size and quality.

  • Make a first typed Jev decision from Python or TypeScript

    Send one state and a few typed questions to Jev and read back probabilities.

    View prompt
    Using the typesafe-sdk-python repo at https://github.com/typesafe-ai/typesafe-sdk-python and the quick start at https://docs.typesafe.ai/introduction/quickstart, write a script that sends the state <state> with one Choice question over <options>. Expected output: the chosen option and its confidence. Verify that the answer is one of the options you passed in.

  • Point existing AI scripts at a private local API

    Redirect scripts written for the OpenAI or Anthropic API to a model on localhost.

    View prompt
    Take the script at <target script> that calls an OpenAI or Anthropic style API and point its base URL at the PolyStrata server on localhost, using model <model name>. Expected output: the script's summary of <input file> produced without any remote request. Verify that the output is a usable summary and that the network traffic goes only to localhost.

  • Locate the handbook page that answers an HR question

    Runs flat page search on a short PDF to return the most likely page and its text.

    View prompt
    Using the repo VectifyAI/jev-doc-search, run page_search.py on <path-to-pdf> with the question <question>. Output the most likely page label and its text. Verify that the page text contains the answer by checking the wording against the PDF.

  • Send a finished edit to VEED's editor as a project

    Turn a finished plan into a VEED project a person can edit further, then pull it back.

    View prompt
    Using the Open Edit repo at veedstudio/open-edit, run veed-project on <plan file> and then open the resulting VEED project. Expect the editor to show footage, text, captions, and audio as separate items. Verify that the project opens in VEED before you tell the user it is ready.

  • Run a factory task from your machine with the dev TUI

    Give the factory a task from your terminal and approve changes before they reach GitHub.

    View prompt
    In the eve-software-factory-template project, run `vercel link`, `vercel env pull`, and `pnpm dev`, then give the factory the task <task description>. Verify that the four stations run in order and that no change reaches GitHub until you approve it in the TUI.

  • Write a long-form blog post and get a Notion page link

    Have the content marketer draft a blog post or landing page and return a Notion page to edit.

    View prompt
    Using vercel-labs/marketing-team-eve-template, ask the lead agent to have the content marketer write a blog post about <topic> for <audience>. Expected output: a Notion page link to the draft. Verify that the draft uses the product claims in the brand context document.

  • Try an agent skill without installing it

    Generate a skill prompt or launch a supported agent with a skill for a one-time run.

    View prompt
    Run the vercel-labs/skills CLI to print the prompt for the <skill name> skill from <source repo>, without the --agent option. Report the first five lines of the prompt and confirm that no skill was installed into the project.

  • Coordinate several DSH session windows as one team

    Route tasks between DSH session windows and let one window act as team lead.

    View prompt
    In the vibeinging/dsh-desktop setup, ask the session window <placeholder> to hand a short task to another named window and report whether the message appeared in the target window as a real DSH message. Verify that the team state is stored through the official Session API in the current profile and that no external network connection is made, as the README states.

  • Check and prompt running agents from your phone

    Start a session on your laptop, then follow and prompt it from the Vicoa mobile app.

    View prompt
    Using the vicoa-ai/vicoa repo, start a coding session on <target-project> with the Claude Code agent and a prompt to <task>. Confirm the session appears in the Vicoa mobile app under the same account and that a notification arrives when the agent asks a question or finishes. Report the session status seen on the phone.

  • Make an interactive product assembly for design review

    Model a product or mechanism, such as a gear pair or folding lamp, as an explorable scene.

    View prompt
    Using the 3dviz-pro-max skill in <repo-path>, build an interactive Three.js assembly of <product or mechanism>, with parts that connect and move. Reuse a suitable kit blueprint if one fits. Report which parts were modeled, what motion was observed, and which frames were captured.

  • Draft routing rules with a loopback-only model

    Use a locally installed Ollama model so the intent stays on 127.0.0.1 instead of going to OpenAI.

    View prompt
    In the Vincent-Xi08/IntentRoute-AI repo, configure the Ollama provider with the model <model name> and generate a draft for the intent <intent text>. Expected output: a disabled rule draft and a health report showing loopback reachability and that the model is installed. Verify that the app only queries 127.0.0.1 or ::1.

  • Build a product demo that clicks through your app

    Rebuild your app's screens in Explainroo and film a pointer walking through them.

    View prompt
    In the explainroo repo at <repo folder>, make a product demo for <product name> using its site at <site URL>. Rebuild its screens with the same colors, fonts and button labels, then render an MP4. Expected output: one product demo MP4. Verify that every button label matches the real product before you publish.

  • Convert an article or document into a video

    Feed a written article or document to the skill and get a narrated video of its key ideas.

    View prompt
    Using the anything2explainer skill in this repo, turn the document at <path-to-document> into a narrated explainer video in <language>, about <length> long. Pause at the narration sign-off so I can edit the script. Verify that the narration covers the main points of the document and that the output is an MP4 with subtitles and chapter progress.

  • Add clearer-response checks to Codex sessions

    Install the Nopus Codex plugin so each completed answer gets a bounded check for abstract prose.

    View prompt
    Using the nopus repo at Vistyy/nopus, run `codex plugin marketplace add Vistyy/nopus` and `codex plugin add nopus@nopus`, then start a new Codex session in <project directory> and run `$nopus-configure medium`. Expected output: the plugin installed and the sensitivity set to medium. Verify that a long, abstract Codex answer triggers the message "nopus requested a clearer rewrite."

  • Split a large coding task across a team of agents

    Let a planner session split work into parts that executor sessions build in parallel.

    View prompt
    In the VelaTerm desktop app, open the project at <project-path>, start Plan / Execute mode, and give the planner this task: <task-description>. Expected output: a planner session with child executor sessions, each working in its own worktree, and a list of reports for review. Verify that each executor has a separate worktree before any edits begin.

  • Investigate a Grafana alert with an AI assistant

    Use the official Grafana MCP server to search dashboards and query datasources while you look into an incident.

    View prompt
    Using the Grafana MCP server listed in VoltAgent/official-mcp-servers, search dashboards for <service-name> and query the related datasource for the last hour. Return a short summary of the metric trend and the dashboard names. Verify that each dashboard you cite was returned by the search.

  • Keep an agent building features over multi-day roadmaps

    Stop an agent from curating receipts and progress metadata instead of building.

    View prompt
    Using the forward-implementation-first skill, work through the roadmap in <roadmap-file> in the <repo-name> repository, building features and running focused validation without generating hashes, locks, or certification markers. Report each completed item with its validation result. Verify that every reported result comes from a test, benchmark, or end-to-end run rather than a receipt.

  • Add Todoist reminders and control Home Assistant by chat

    Connect Todoist and Home Assistant so one chat bar can add reminders and switch devices.

    View prompt
    In the jev-chat repo, set TYPESAFE_API_KEY, TODOIST_API_KEY, HASS_URL and HASS_TOKEN in .env to values from <your-accounts>, then run pnpm tools:list. Expected output is the tools each connected server exposes. Verify that the Home Assistant server is listed before sending a light command.

  • Filter a social feed with a Jev classifier

    Adapt a listed feed-filter demo to score posts as you scroll.

    View prompt
    Using the repo walidboulanouar/awesome-jev-use-cases, read the Content and growth section and the Patterns section, then write a function that sends one post text from <posts-file> to the Jev API and returns a keep or hide decision with a confidence value. Verify by running it on 50 saved posts and confirming every result is keep or hide.

  • Add the HERO block to Codex's AGENTS.md

    Put the same contract in AGENTS.md so Codex follows the scope limits on each run.

    View prompt
    Confirm that the HERO SCOPE LIMITS block from RULES.md is appended once to <project>/AGENTS.md. Then complete <task> and report whether any change was made under rules 2, 3 or 4 that the task did not require.

  • Edit and export a sample architecture diagram with no API key

    Load the bundled demo session and drag, relabel, and export a diagram without any model settings.

    View prompt
    Using the architecture-canvas repo at https://github.com/weike-zhang/architecture-canvas, run python3 demo.py --output demo-session.json, import that file into the local page, and export the diagram as SVG. Expected output: an SVG file of the sample knowledge assistant diagram. Verify that the file opens offline and that no model or search request was made.

  • Turn on the built-in You should know mod

    Enable Anthropic's built-in side agent that flags things you or Claude might miss.

    View prompt
    In a Claude Code session on version 2.1.287 or later with telemetry on, run `/plugin enable cc-plugin-you-should-know@builtin`, then confirm the mod is enabled and report what it shows after one task. Do not change any other plugin settings.

  • A/B test a typed Jev decision against a prompt

    Swap in the official drop-in adapter to measure Jev against an ordinary LLM on your data.

    View prompt
    Using the awesome-jev-live README, locate typesafe-ai/system-one-adapter-python and typesafe-sdk-python. Build an A/B harness on <your labelled dataset> that runs both clients on identical typed questions. Output an accuracy table per backend and verify that both return the same answer type.

  • Give a team chat access to its own tools via MCP

    Add MCP integrations, with OAuth, so Whirl can work with the tools your team already uses.

    View prompt
    In the whirlchat/whirl repo, read the apps/console directory and the docs/configuration.md file, then describe how to add an MCP integration with OAuth for <target-tool>. Output the exact steps and any environment variables needed. Verify each claim against the README or docs before reporting.

  • Train a mixture-of-experts model across 8 GPUs

    Use Expert Parallelism on a MoE model to spread experts over 8 GPUs with one launch command.

    View prompt
    In the whitecircle/halo repo, launch the MoE SFT example with `halo launch sft <target-config> -n 8 --expert_parallel_size=8` inside the Halo image on an 8-GPU node. Expected output: a completed run with expert shards in the output directory. Verify with `--dry-run` that the EP setting appears in the printed command before the real run.

  • Run the DSHCode Web UI from source for development

    Clone the repo, install dependencies, build, and start the local Web UI with pnpm.

    View prompt
    Clone https://github.com/whitelonng/dshcode, then run pnpm install, pnpm run build, and pnpm dsh web in <target folder>. Report the local Web UI address the command prints and confirm it responds to an HTTP request. Follow AGENTS.md in the repo before editing any files.

  • Run Qwen-Image 2.1 in ComfyUI on an 8 to 12 GB GPU

    Use the INT4 ConvRot pack or Comfy-Org int8 files in a recent ComfyUI build.

    View prompt
    Using wildminder/awesome-qwen-image, set up ComfyUI with the int8 ConvRot Image Model and Text Encoder from Comfy-Org/Qwen-Image-2.1 in the folders listed in the README, then generate one image from the prompt <prompt>. Report the file paths used and the output image path. Verify that the Image Model is in models/diffusion_models/ and the text encoder is in models/text_encoders/.

  • Animate a sprite and export a spritesheet for your engine

    Turn a drawn character into a tagged animation and export it as a spritesheet.

    View prompt
    Using the aseprite-ai-artist plugin from with-pebbly/aseprite-ai-artist, animate the open sprite <sprite name> as a <number>-frame <idle or walk> cycle and export a spritesheet with its atlas for <engine>. Expected output: a tagged cycle in the Aseprite document and an exported spritesheet and atlas file. Verify that the frame count and cycle tags match the request before exporting.

  • Track request volume, tokens and cost per model

    See which models, providers and client keys drive usage and spend across CPA requests.

    View prompt
    Use the Oh My CPA console at http://127.0.0.1:8080/omc/ in the <deployment-directory> directory to find the three models with the highest cost over the last 7 days. Report each model with its request count and cost. Verify the totals match the Request records filter for the same range.

  • Verify reward models load before a long training run

    Run the README setup checks and gradient smoke tests so a failed reward stack does not waste GPU hours.

    View prompt
    In the repo worldbench/DiffusionOPSD, run the reward setup checks for <reward name> with the SD3.5 backbone and the gradient smoke test. Report which commands passed or failed and the error text for any failure. Verify that the smoke test ran the differentiable reward path before reporting success.

  • Serve Spark-X2.6-4B as an API with SGLang on NVIDIA GPUs

    Run an OpenAI-compatible endpoint with tool-call and reasoning parsers enabled.

    View prompt
    Using the Spark-X2.6 README SGLang NVIDIA GPU server block, start an OpenAI-compatible server for the checkpoint at <MODEL_PATH> on port 30000 with served model name spark2.6. Send the chat request <your prompt> to http://localhost:30000/v1/chat/completions and report the reply text. Verify that the response JSON has a choices array with non-empty content.

  • Keep a rolling full DSH backup without manual exports

    Turn on scheduled backups with a fixed cadence and a retention policy that keeps old copies thinned out.

    View prompt
    In DeepSeek Harness on <machine>, use the DSH Config Manager plugin to enable Scheduled backup with a 24h cadence and the default retention policy. Report the next scheduled run time and confirm that the backup contains no secret values.

  • Verify a paper's metrics by running its code in a sandbox

    Run a paper's repository in the Docker boundary and get a PASS, FAIL, or PARTIAL verdict.

    View prompt
    Using the VeriRepro repo (XiantingWu/VeriRepro), run `verirepro doctor --strict` and then `verirepro reproduce <paper-id>` for the paper <paper-id>. Expected output is a workspace with report.json and a PASS, FAIL, or PARTIAL status. Verify that any PASS is backed by evidence-authorized scalar comparisons and not just a zero exit code.

  • Have ChatGPT review Codex changes without uploading the repo

    Send ChatGPT only the workspace lines it needs to review what Codex wrote.

    View prompt
    In the workspace at <workspace path>, with the codex-with-chatgpt bridge running, ask Codex to use ChatGPT to review the changes for <change>. Report the review findings and confirm that Codex made no edits without approval.

  • Continue long ChatGPT tasks in a fresh conversation

    Hand off a long-running task to a new chat using a stored summary and a UUID.

    View prompt
    Using the openchatx-mcp repo, call summarize at the end of the current task and return the UUID. In a new chat, call summarize with the UUID <uuid> and continue the task at <next-step>. Verify that the reply names the last completed step from the stored summary.

  • Find which items a new assistant version fixed or broke

    Compare two saved runs item by item to see exactly what changed between versions.

    View prompt
    In the keystone-bench repo, compare two saved runs with keystone regress runs/<old> runs/<new>. Report the items that regressed and the items that were fixed, and confirm both runs used the same quick layer.

  • Review and revise an Amazon listing with the listing optimizer

    Use the Listing optimizer Skill to get a revised listing draft and a list of claims to verify.

    View prompt
    Using the sealeap-amazon-skills repo, run sealeap-amazon-listing-optimizer on the current listing for <product or listing name> in <marketplace>. Expect a revised draft, a change log with reasons, and a list of claims needing verification. Confirm that each change is tied to a stated reason and that no claim is presented as verified without a source.

  • Keep an AI on a project roadmap with project progress MCP

    Run the project progress MCP so the AI records changes and future goals as it works.

    View prompt
    Use the project progress MCP from xop01/project-progress-mcp on <project path>. Record completed changes, the current feature and the next goals as you work. Expected output: an updated roadmap and the next step after finishing a side task. Verify that the main path is still listed after the side task.

  • Analyze SPSS .sav data files by describing the analysis

    Point Baize at an SPSS data file and ask for summaries or statistics in plain language.

    View prompt
    Using the Baize CLI from the Xu123-Bob/Baize repo, ask it to open <path-to-sav-file> and produce a descriptive summary of its variables. Expected output: a variable list and summary statistics. Verify that the variable names in the output match the names shown in the file metadata.

  • Store and search text facts with Voice Mem

    Save plain text facts in a fact-only mode and retrieve them with a search query.

    View prompt
    In the VoiceMem repo at <repo path>, write a script that creates VoiceMem with mode leftbrain_only, ingests the text <fact text>, and searches with the question <question>. Expected output is the stored fact in result_leftbrain. Verify the search returns the fact after ingest.

  • Read a 500K-token document in one prompt

    Load a very long report or codebase dump and query it locally with context up to 500K tokens.

    View prompt
    In the Yamz-Labs/kyojin repo, start tools/qwen/serve.py with -c 524288 and --cache-bits 8 for the Qwen pack, then send <target document> as a single prompt. Expected output: an answer that cites facts from the document. Verify by checking two facts from the start and end of the text against the source before reporting.

  • Track a project in a shared Slack channel

    Keep a project's updates and follow-ups in a shared channel with the team's agent.

    View prompt
    Using the repository yc-software/qm, set up a shared Slack channel named <channel name> for tracking the project <project name>. Have the agent post a status summary and list open follow-ups. Verify that the summary contains only information from the channel and the project's shared scope.

  • Trace attention variants from code to table rows

    Map the attention types in the table, such as GQA, sliding window, and MLA, to their implementations.

    View prompt
    In the repo YeonwooSung/llm-architecture-from-scratch, find the folder for <attention type> from the Attention column and summarize how its heads are built. Output a bullet list of code-level differences from Grouped-Query Attention. Verify the folder name matches the README link before reporting.

  • Find the edit that broke a test and restore the file

    Use Time Machine's step timeline and shadow-git snapshots to locate and undo a breaking edit.

    View prompt
    In the repo YeonwooSung/my-claude-code-mods, install time-machine at user scope, then after a failing run of <test command> identify the tool call that introduced the failure. Output the step number, the file changed, and the restored content for that file. Verify the result by re-running <test command> after the restore and reporting pass or fail.

  • Turn a product topic into a finished short promo video

    Pick a built-in style template and let the pipeline produce images, video, and a composed final cut.

    View prompt
    Using the printfilm repo running at http://localhost:8080, create one AI short video for the topic <topic> with a built-in template in full mode. Report the project ID and the final composed video status, and confirm that every storyboard shot finished.

  • Vet a listed Jev project before you adopt it

    Run the README's five checks on one project to see if it uses Jev and can be tested.

    View prompt
    Using the checklist in the yibie/awesome-jev README under Curation is not endorsement, check <project repo URL> for a Jev API call, a runnable test or demo, a license file, and the share of code versus prose. Expected output: a table with one row per check marked pass, fail, or unclear, each with a file path as evidence. Verify that every pass cites a real file path in the target repository.

  • Score drafts against a rubric and yes/no checks

    Rate a text on rubric criteria and get yes/no probabilities for checks like policy compliance.

    View prompt
    Using the LLM2Jev repo, call systemone.create on the running service with the draft text <draft-text>, a Score rubric for <rubric-criteria>, and a Noul yes/no check for <check-question>. Return the rubric scores and yes/no probabilities as JSON. Verify that each score is returned for every rubric item before reporting.

  • Build an incident walkthrough with failure paths and fallbacks

    Create an explainer showing impact, symptoms, and fallback behavior for an incident.

    View prompt
    Using the fireworks-open-eli5 Skill, build an incident explainer for <incident description> with impact, symptoms, fallback, and teach-back questions, grounded in the cited evidence. Render it to <output.html> and validate it. Report which failure steps lack a source locator.

  • Install the router presets by hand from a clone

    Clone the repo, add the injector, and copy each preset folder into the DSH agent presets directory.

    View prompt
    In the repository yjh051108/dsh-routing-suite, clone the repo, assemble the injector from .\injector, and copy only preset\router-standard and preset\router-spec into the DSH agent presets folder for the user <target-user>. Output the two destination paths. Verify that each destination folder contains a preset.yml file directly, with no extra preset subfolder.

  • Generate a repeatable product shot series from the JSON data

    Filter the product photo prompts in data/prompts.json and reuse one lighting setup across a product line.

    View prompt
    In the awesome-gpt-image-2-5-prompts repo, read data/prompts.json, select the product photo prompt that best matches <product category>, and fill its placeholder tokens for each product listed in <product list>. Return one prompt per product. Verify that each output keeps the original lighting and camera wording and contains no leftover curly-brace or bracketed-capital tokens.

  • Compare AI model replies and latency side by side

    Send one prompt to several models in the dashboard and measure response latency.

    View prompt
    Using the repo yudaprasetya007/routeVSCODE, start the 9Router gateway and the dashboard with npm start, then run the Live Model Comparison with the prompt <test prompt> on the models <model list>. Report each model's reply length and measured latency, and verify that every selected model returned a response before giving a recommendation.

  • Have an agent apply reviewer feedback to the TeX source

    Send feedback files to a coding agent that edits canonical TeX, rebuilds, and reports decisions.

    View prompt
    Read and follow skills/pairtex-agent/SKILL.md in the PairTeX repo. Consume the open feedback in <paper-path>/.pairtex/feedback/, apply changes only to canonical TeX source, rebuild, and regenerate the HTML projection. Report the source diff, build result, and which entries were resolved, and verify that any unresolved entry has a thread reply.

  • Re-run one scenario family to debug a harness

    Narrow scoring to one family, such as headless or permission, to find a failing area.

    View prompt
    Use the repo YuyaoGe/doc2harness to re-run only the <family-name> scenario family against the product at <path-to-product-directory>. Use tools/run_production_catalog.py with --family <family-name> and report which scenarios failed. Verify the catalog still loads with the family filter applied.

  • Diagnose ad fatigue and brief the next creatives

    Find which ad concepts are fatigued and get a ranked brief for the next batch.

    View prompt
    Using the marketing-os skill in the Yuzzyuk/marketing-os repo, run the paid-ads module on the performance data for <campaign name> and return a concept-level fatigue diagnosis with a ranked production brief. Verify that each ranked brief item names the concept it replaces and that no winner is declared from a handful of conversions.

  • Make 5 s audio-video clips on an 8 GB consumer GPU

    Use the --low-vram path to run the DMAD students on an 8 GB GPU by streaming weights from the checkpoint files.

    View prompt
    In the Yzmblog/DMAD repo, run inference.py with --low-vram 8 and the lora_critic checkpoint on the prompt file <prompt_file>, writing to outputs/<name>. Expected output: 5 s MP4 clips with audio in the output folder. Verify that the run finished without an out-of-memory error and that settings.json lists the low-vram setting.

  • Run the terminal agent from source on a project

    Build and launch the Agent CLI and TUI directly from the apps/zcode-cli source.

    View prompt
    In the zai-org/ZCode repo, run `pnpm bootstrap` and then `pnpm --filter @zcode/cli dev --help`. Report the available options and state whether the help text lists a non-interactive mode.

  • Test RAG tenant boundaries with controlled fixtures

    Measure whether one tenant's documents can surface for another tenant using benign fixtures you control.

    View prompt
    Using the rag-data-exposure-audit skill from the zero-lab-ai/skills repo, test the retrieval endpoint <endpoint-url> with the canary fixtures I created in tenants <tenant-a> and <tenant-b>. Return one exposure state per boundary, with the query and the returned canary. Verify that every canary returned belongs to the tenant named in the result.

  • Run one command across several SSH sessions at once

    Open SSH, SFTP, and other remote sessions in one terminal and send commands to all of them together.

    View prompt
    Using the AI Security Tool repo at https://github.com/ZeroDayEvil/ai-security-tool, open SSH sessions to the hosts in <hosts-list> and enable multi-input broadcast to run a read-only disk usage check. Expected output: one result block per host. Verify that every session returned output and that no session shows a connection error.

  • Explain an Android APK's code and resources with an agent

    Open an APK with jadx Java output and let an agent trace its manifest, resources and native libraries.

    View prompt
    In the Zfinix/eleven repo, open the APK at <path-to-apk> and ask the agent to summarize its manifest, permissions, main components and native libraries. Expected output is a list with a Java class or resource path for each item; verify two of them in the Java view.

  • Build a cited literature table for a harness project

    Turn the reading list into a sourced table of methods, venues, and one-line contributions.

    View prompt
    Using the repo at https://github.com/zgcagi/Harness-RSI, extract every entry in the Interpreted Update Targets section into a markdown table with columns method, venue, one-line contribution, and paper link. Output the table only. Verify that each venue and year matches the README text exactly.

  • Review DSH turns with a second model's advisory notes

    Have a separate model flag issues in each DSH turn without blocking the main agent.

    View prompt
    Read the README of the repository at <plugin repo URL> (dsh-advisor) and summarize how the reviewer model is configured and how advisory notes are presented. Expected output: a short setup summary for a DSH project at <target project path>. Verify that the README states the notes do not approve or reject the primary agent's actions before you report that behavior.

  • Run DeepSeek Harness from an AppImage that updates itself

    Run the single-file AppImage without installing it and let it check for updates.

    View prompt
    For the repo Zhou-Yujing114514/deepseek-harness-linux, download the x64 .AppImage into <target-folder>, make it executable, and start it with `./deepseek-harness-*-linux-x64.AppImage`. Report whether the app window opens and which SHA256 checksum you compared against the one on the Releases page. Verify the checksum matches before you run the file.

  • Find the search terms behind a new AI name

    Turn a new name into the generic searches people make, sized and checked for page-one room.

    View prompt
    In the new-term-radar repo, produce the keyword table for today's new names and return the rows with their decision and page-one status. Verify that no prioritize row has a crowded page one, since the README relabels those as watch with a down arrow.

  • Clean up hair edges and export a mask for design tools

    Refine a cutout's outline and hand edits, then save the alpha channel as a black-and-white matte.

    View prompt
    Using the unbagrnd app from github.com/zidniryi/unbagrnd, refine the cutout of <image path> and export its alpha channel as a black-and-white matte. Expected output: a grayscale image where the subject is white and the background is black. Verify that the matte contains only black and white pixels.

  • Turn a model failure into a reproducible handwriting batch

    Trace a failed case to its seed and generation record, then regenerate a matching batch.

    View prompt
    In the VeriInk repo, read docs/ and src/veriink/, then open examples/gallery/manifest.json. For the failure pattern <failure-pattern>, list the matching records with their seed, labels, bounds, and SHA256. Verify that each listed seed, when used for rendering, is covered by the existing validation checks.

  • Build a retrieval corpus from the freight case study

    Use the Week 1 seeded freight data as the retrieval corpus for a RAG exercise.

    View prompt
    In the AI-Engineering-Lab repo, complete curriculum/week-01 to generate the freight dataset under data/, then build a small retrieval index over it for the Week 7 exercise. Return the retrieval query you tested, the metric you chose, and one error note.

  • Check a screen flow by element ID or on-screen text

    Tap buttons by resource-id or text, verify the next screen, and fall back to OCR when the UI tree is empty.

    View prompt
    Using the dsh-android plugin, call android_ui_tree on the streamed device, then call android_tap_element on <element resource-id or text> with expect_text set to <text expected on the next screen>. Expected output: a tap result that reports whether the expected text appeared, plus a screenshot path. Verify the expect_text check passed before moving to the next step.

  • Tap app controls by label and confirm the result

    Drive a simulator app by accessibility identity and check the expected text appears after each tap.

    View prompt
    Using the dsh-ios plugin in the ZSeven-W/dsh-ios repo, call ios_sim_tap_element on the simulator <udid> for the element labeled <label>, with expect_text set to <expectedText>. Report the expected.matched result and the screenshot path. Verify that expected.matched is true before you confirm the step passed.

  • Smoke-test exported Evo VLM programs without weights

    Import the selected inference programs and check their interface on a CPU before any GPU setup.

    View prompt
    Clone https://github.com/zzzz7788990213-ops/EvoVLM and enter research/evolving-vlm-inference-main. Run `bash reproduce.sh smoke` and list each best_*.py file with whether it imports and passes the interface check. Verify that no model weights were loaded and no inference ran.

  • Prepare a stage-specific interview pack

    Build a prep pack and mock interview for a scheduled interview on a tracked application.

    View prompt
    In the ai-job-search repo, run /interview for the tracked application <application name>. Expect a prep pack built from the archived posting, CV and cover letter, with likely questions mapped to STAR examples. Verify that no experience appears in an answer that is not in your archived documents.

  • Run a single-cell RNA-seq analysis with Scanpy

    Have an agent follow the Scanpy skill to process a single-cell dataset and report clusters.

    View prompt
    Using the scientific-agent-skills repo and its Scanpy single-cell skill, process the dataset at <dataset path> with quality control, clustering, and a cluster summary. Return a script and a short report of cell counts per cluster. Verify the cell and gene counts before and after filtering.

  • Turn a complex workflow into a simple app or API

    Use App Mode and the local API to run a saved workflow from a form or a production pipeline.

    View prompt
    Using the ComfyUI repo at https://github.com/Comfy-Org/ComfyUI, save the workflow <workflow name> as JSON, expose its prompt input through App Mode, and submit it to the local API with the prompt <prompt text>. Expected output: one generated file returned by the API and the saved workflow JSON. Verify the API response status and that the output matches the prompt.

  • Share project knowledge across a team on one server

    Point the whole team at one AI Memory server so each person's agents can retrieve shared project notes.

    View prompt
    Using the ai-memory repo (github.com/akitaonrails/ai-memory), set up a shared memory server for <team-name> and create one personal key per member. Expected output: each member's agent can search the shared project pages. Verify by searching for a known project fact from a second member's account.

  • Fine-tune Kronos on your own market dataset

    Adapt the Kronos tokenizer and predictor to your own candlestick data using the Qlib-based finetuning pipeline.

    View prompt
    In the Kronos repo, edit finetune/config.py for my local Qlib data at <qlib data path>, run the preprocessing script, then run both torchrun training scripts with <number of GPUs> GPUs. Verify that train_data.pkl, val_data.pkl and test_data.pkl exist in dataset_path before starting training.

  • Trace how two components connect before a change

    Find the path between two modules or concepts to see what a change could affect.

    View prompt
    In the Graphify-Labs/graphify repo, run `graphify path <node-a> <node-b>` against the graph in <project-path>/graphify-out/. Expected output is the chain of nodes connecting the two, with edge tags; verify each hop has a source location before listing it as a dependency.

  • Move Claude Code and Codex sessions into DSH

    Use dsh-claude-move to bring sessions, memories, skills, and slash commands into DSH with approval gates.

    View prompt
    Using the repo 0xsline/awesome-deepseek-harness, install dsh-claude-move from github:PerryLink/dsh-claude-move into DSH. Run its migration wizard for <source tool: Claude Code or Codex> and report which sessions, memories, and skills were moved. Verify the migration is idempotent by running it a second time and confirming no duplicates appear.

  • Find a narrator voice and save it under a short name

    Search Fish Audio's community voices, choose one, and reuse it under a short name.

    View prompt
    Using the repo 100yenadmin/fish-audio-hermes, search the Fish Audio voice library for a deep British narrator and save the best match as the alias narrator with `/fish alias add`. Expected output: a voice id saved under the name narrator and shown by `/fish alias`. Verify that `/fish status` reports narrator as the active voice.

  • Test whether a math tool rejects a convincing wrong answer

    Run the nine-call integration probe to see reject, repair, learn, and recall before adopting it.

    View prompt
    Using the ResiMind repo at <repo path>, run the nine-call integration probe from docs/algebra-repair-cases.md against my agent. Expected output: a table of reject, repair, learn, recall, and unsupported-scope results. Verify that the wrong-answer call is rejected before any repair is accepted.

  • Run a multi-step bash plan in one MCP call

    Use bash_batch to compile and run a known sequence of commands with one result per step.

    View prompt
    Using the fauxnix `bash_batch` tool from the 20000419/fauxnix repo, send a two-step plan that writes a file named <file-name> and then counts its bytes with `wc -c`. Expect one structured result per step in one response, and verify the byte count matches the content written.

  • Evaluate SpeakerMem on SocialMemBench with a local Writer

    Run the main SpeakerMem evaluation with a locally served Writer model instead of an external LLM.

    View prompt
    In the SpeakerMem-R1 repo (2022hpsk/SpeakerMemR1), run speakermem_pkg/examples/socialmembench.py on SocialMemBench with --top-k 10 --s2-k 2 --s2-source-k 1 and a local Writer URL given as <writer-url>. Expected output is results written to the results directory you choose. Verify that the summary reports accuracy for the socialmem domains and that no ASK route was enabled, since the README says the principal comparison uses the no-ASK configuration.

  • Stop a long AI coding session from losing grounded facts

    Hand off a long task to a file-backed state so a fresh context keeps verified facts.

    View prompt
    Using the reverify repo at 2akouwu/reverify, run reverify rollover to hand off the current session, then run reverify ledger <target> and confirm the established and known-false facts appear in the new session before continuing.

  • Check a business plan for blind spots before deciding

    Have several configured models answer, review, and rank two planning options.

    View prompt
    Using the a1exsun/dsh-council repo in DSH Web, run /council on this planning question: <two options with constraints and deadline>. Return the recommendation, the listed blind spots, and the points where the models disagree. Verify that the question contains no confidential figures before sending it.

  • Check Jev designs against the live API

    Store a TypeSafe API key so the agent can test its Jev code before it reaches your project.

    View prompt
    Using the building-with-typesafe-jev skill, write a small Jev call for <target task> and test it against the live API using TYPESAFE_API_KEY. Report the response and any field-name errors. Verify that the agent printed the key length only and never the key itself.

  • Delegate a code fix, test run, and pull request to a bot

    Give a bot a repository and ask it to implement, test, and open a pull request.

    View prompt
    Using AbacusAI Bot, register the local repository at <repo path> as a workspace for a bot, connect GitHub, and ask it to fix <issue>, run the test suite, and open a pull request. Report the branch name and test results. Verify that the test command actually ran and the diff matches the issue.

  • Resume the LIBERO agent runner and skip passed tasks

    Run the agent over all three LIBERO suites so that tasks already passed are skipped on each rerun.

    View prompt
    In the EvoBot repo at <repo path>, run darwin.agents.libero_runner for the three suites with the PYTHONPATH and MUJOCO_GL settings from the README. Report how many tasks were skipped as already passed and how many were newly run. Verify the counts against the entries in logs/libero_agent_progress.json.

  • Branch or fork a Pi conversation from any message

    Try another direction from an earlier message without losing the original session.

    View prompt
    Using the abcwyc/pi-agent-desktop README, explain how to branch and how to fork a Pi conversation from an earlier message. Expected output: a short list of the two options and when to use each. Verify that the README names both branch and fork actions before answering.

  • Map entry points and sinks in a source repository

    Rank source files, map entry points, and trace risky sinks for a code audit.

    View prompt
    Using the Ablation repo at ~/ablation, audit the source repository at <repo path>. Produce a ranked file list, a table of entry points and sinks, and a coverage summary of reviewed versus unreviewed files. Verify that every listed sink has a traced path from an entry point, or is marked as untraced.

  • Brief a new product film from the review-note prompts

    Reuse the saved prompts and review notes to direct a launch film for a different product.

    View prompt
    Using the repo AbubakrChan/product-launch-motion, read references/prompts.md and use its prompts and review notes to brief a launch film for <target product website>. Expect a new 60 fps MP4 that follows the one-shape and springs rules. Verify that the brief contains no copied text from the target product's website and that the music is a licensed track.

  • Make a narrated explainer video synced to speech

    Match 3D and math animations to spoken narration using self.say() in a Python scene.

    View prompt
    Using the manimgx repo at github.com/academa-labs/manimgx, write a scene.py for <target lesson> that uses self.say() to sync narration with self.play() animations, then run manimgx render scene.py. Expected output: an MP4 with speech-synced animations. Verify that each animation starts at the matching spoken line.

  • Review agent diffs line by line and send comments back

    Comment on an agent's diff in ACRYL and send those comments straight back to the agent.

    View prompt
    Using the acryl repo at github.com/acryldev/acryl, open the diff for the worktree at <worktree-path> in ACRYL, add a review comment on one changed line, and send it to the agent. Report the line number and the agent's reply, and verify the comment appears in the session.

  • Sort an issue backlog into implement, spec, or wait

    Have a triage run classify each untriaged issue and write a handoff comment with its gate level.

    View prompt
    Using the addyosmani/factory skills in <target-repo>, run the triage stage on the open untriaged GitHub issues. Expected output: a list of issues with the factory:* label applied to each and a one-line reason. Verify that no code was changed and that every issue has exactly one queue label.

  • Review ADCS ESC1 through ESC17 misconfigurations

    Check certificate services for ESC1 through ESC17 weaknesses with the adcs-attacks skill and certipy.

    View prompt
    Using the Claude-AD repo (ADScanPro/Claude-AD), apply the adcs-attacks skill to the certificate authority <ca-name> in the authorized domain <target-domain>. Expected output is a table of matched ESC variants with the certipy check and the fix for each. Verify that every finding cites a template or setting you actually enumerated.

  • Propose a partnership to connect model or channel reach

    Open a partnership issue to link model capacity or channels with real user demand.

    View prompt
    Read the Value for the ecosystem section of the adtexterry-lgtm/unigit-ecosystem README and draft a partnership proposal for <partner name> as a <partner role>. Expected output: a short proposal that names the partner role, the user demand, and the public contact details. Verify that the proposal uses only public information and includes no credentials.

  • Carry your personal agent rules into every project

    Store your own standards and knowledge in a user partition that applies across all your repos.

    View prompt
    Using the Operator Memory repo (https://github.com/aerovato/operator-memory), set up the user partition and record this standard: <standard-text>. Expected output: a Markdown file under ~/.operator/user/ containing that standard. Verify by opening a different project and checking that the agent applies it.

  • Scan agent prompts, hooks, and permissions for security issues

    Run AgentShield over an agent setup to check prompts, hooks, MCP config, permissions, and secrets.

    View prompt
    Using the ecc-agentshield package from the ECC project, scan <project-path> for issues in prompts, hooks, MCP config, permissions, secrets, and agent files. Return a list of findings with file paths and confirm that no secret values appear in your output.

  • Set a Loop to wake Comma only when something needs it

    Have Comma write a small watcher that acts only when an inbox, repo, or feed changes.

    View prompt
    Using Comma from the AFK-surf/Comma project or the hosted comma.surf service, ask the agent to create a Loop that watches <inbox, repository, or feed> and wakes the agent only when <trigger>. Report the Loop's name and what it watches. Verify that a test event produces a Task on the board without waking the agent for unrelated events.

  • Hand a coding fix to senior-dev on its own branch

    Describe a bug and let senior-dev change code in a private copy, then check the results.

    View prompt
    Use the CodeAF repo at Agent-Field/CodeAF. Install it, open the git repository at <project-path>, and run `/senior-dev <describe the bug and tests>`. Expected output: a submitted change on its own branch with build and test results. Verify that your working branch and main were not changed and that the reported test results match a local run.

  • Add items to a cart in a profile that stays signed in

    Reuse a Chrome profile that is already signed in to run cart tasks without a password.

    View prompt
    Use the fastbrowse repo to add <item> to the cart on <site URL> using the profile at <profile dir>. Run `uv run fastbrowse "<task>" --start <site URL> --profile <profile dir>` and report the status and cost. Verify the item appears in the cart in that profile.

  • Review local token usage and sessions across agents

    Check token counts, requests, sessions, and models for each agent from the local usage dashboard.

    View prompt
    Using the Agent Launcher repo at https://github.com/agent-launch/agent-launcher, open the usage dashboard and summarize token counts, request counts, sessions, and models for <agent-name> over <time-period>. Expected output: a short table of those figures per agent. Verify that the numbers come from local session records only and that no data was uploaded.

  • Pick a Python agent framework for a multi-agent prototype

    Narrow the Python agent frameworks to one that fits a role-based or tool-using prototype.

    View prompt
    From the Agent builders and frameworks section of the Agenta-AI awesome-ai-agent-platforms repo, list the Python frameworks that describe multi-agent or role-based coordination. Return the best match for <prototype goal> with its license and GitHub link. Check that the license matches the framework's repository before reporting.

  • Keep an agent checking its inbox on a schedule

    Set up a recurring check so an agent picks up new messages from its durable inbox.

    View prompt
    Install the AgentPeerChat skill from the CLI, ask me for a sync interval, and create the recurring check only after I choose one. Return the task ID, interval and enabled state, and report connected but not listening if scheduling is unavailable.

  • Build and check Nautilo from source before a code change

    Clone the monorepo, start a dev stack, and run the standard checks before you submit a change.

    View prompt
    In a checkout of the agentsea/nautilo repo at <path>, confirm Bun 1.3.11 and Node 24.x are installed, then run bun run lint, bun run typecheck, bun run test:unit, and bun run lint:unused. Report pass or fail for each and the first error. Read AGENTS.md and README.ai before editing any file.

  • Approve each sales email before it leaves

    Have a Sales Director draft outreach and send only the emails you approve on Needs you.

    View prompt
    Using the repo agentvivekkumar/dontbemichael, set the sales mailbox <sales mailbox address> to Send on approval for the Sales Director team member. Report the number of drafts waiting on Needs you. Verify that no email leaves until you approve it on Needs you.

  • Triage your task list with an agent, approving each edit

    Have a local agent sort Tasks.md while you approve every diff in Obsidian.

    View prompt
    In the Compass vault at <vault path>, read AGENTS.md and 08 Tasks/Tasks.md, then group the open tasks by project or person. Expected output: a proposed list of groups and moves, with no file changed yet. Verify that every proposed edit is shown as a diff and that no note outside 08 Tasks, 04 Projects, and 05 People was touched.

  • Fill a QA seat with a remote OpenAI key

    Run a shadow-worker on a separate machine that uses its own OpenAI key for qa_tester tasks.

    View prompt
    Use the repo AhmadHassan-BTed/AutoSwarm-Shadow-Adapter to start a shadow-worker for the qa_tester role on <remote machine> with the openai provider and model gpt-4o. Expected output: the worker's log showing each claimed task and each submitted deliverable. Verify that the key is read from the LOCAL_OPENAI_API_KEY variable and not printed to the log.

  • Plan your first 50 users and a launch

    Choose the channels to try first and decide how to launch without fear of getting flamed.

    View prompt
    Run first-50-users and then launch-it in the gtm-cofounder skills for <product name>. Expected output: a short channel plan for the first 50 users and a launch checklist with one recommended channel. Verify that the plan matches the Now move in gtm-roadmap.md.

  • Track every application and interview in one place

    See each application on a board or table and a dashboard with your funnel and upcoming interviews.

    View prompt
    Using the AienTech/dossier repo, after it is running at http://localhost:3000, read the applications on the board and the dashboard funnel for the last 30 days. Return a short list of applications with a status and the next interview date. Verify the counts match the number of applications shown on the table view.

  • Sample AI engines by hand with no API keys

    Use a weekly buyer-intent sheet and the Chrome sampling assistant to collect AI answers without paying for API access.

    View prompt
    Using the geolook repo at <repo path>, export the buyer-intent sample sheet and list the 20 questions with their intent group. Confirm that the Chrome extension side panel shows the same queue, then report how many samples are still missing for this week.

  • Sign in to a site with 1Password, keeping secrets from the agent

    Have Chrome Relay type your 1Password credentials so the agent never sees them.

    View prompt
    Using the Chrome Relay repo at aindeev/agent-chrome-relay, sign in to <site URL> by filling the password field with an op:// reference from 1Password, never printing the value. Expected output: the signed-in page's title. Verify that the title matches <expected title> before reporting success.

  • Make a slowed mechanism to teach how it works

    Build a mechanism such as a Swiss lever escapement and slow it down to show each impulse.

    View prompt
    Using the repo AirsupHQ/machine-skill, build a Swiss lever escapement page slowed down for a classroom as one HTML file. The expected output is a single .html file with slow motion, live labels and a computed equations panel. Verify that the page opens in a WebGL 2 browser and that pausing stops the motion.

  • Point at a window element and send a fix request to the agent

    Click a spot in a window, type the change, and load a packaged annotation into chat for the agent to act on.

    View prompt
    In the repo Aisland-SJL/dsh-worktable, a user has sent a point-to-annotate message for window <window-number> at <coordinates>. Apply the requested change to the target element, report which element was changed, and verify the result with a screenshot before finishing.

  • Find why long agent runs stall, truncate, or time out

    Use the documented failure modes and trial outcome classes to explain a failed terminal run.

    View prompt
    Use the alanhuangyoo/crux repository. Read the 'What changed from pi' section of its README, then run the failing <task> from Terminal-Bench 2.1 through harbor with crux.pi_agent:CruxPiAgent. Report which failure class the trial outcome falls into (compaction, truncated output, or idle time) and name the matching agent-layer feature, then verify the classification against the trial output.

  • Find a maintained emulator or client on the web index

    Filter the search site by category and health, then open the repo for a tool you can use.

    View prompt
    Open the search site for alexgaoth/awesome-reverse-engineered, search for <product name>, filter to active projects, and list the top three results with their stars and language. Verify that each result links to a GitHub repo before you list it.

  • Add an interactive mascot to a web page

    Add a small illustration that follows the cursor, reacts to buttons and covers its eyes at password fields.

    View prompt
    Use the anidoodle repo to build an interactive mascot for <site URL or page file>, with cursor tracking, button reactions and a password-field reaction. Return the ES module and the custom element markup, then verify the page works with reduced motion and keyboard navigation.

  • Turn project status into a standup checklist

    Use the Rundown style to get a TL;DR and status checklist you can scan for standups and updates.

    View prompt
    Using the repo alexgreensh/attention-span, install the attention-span plugin in Claude Code and use the Rundown style with /rundown. Then give Claude this status: <your status facts>. Expected output: a TL;DR line, a checklist with status markers, and numbered next steps. Verify that every status in the checklist comes from the facts you gave.

  • Check a knowledge base and build its report and zip

    Run the RES scripts to validate, render and package a study without starting a new agent session.

    View prompt
    In the res repo, run skills/reverse-engineering-saas/scripts/check-kb.mjs on the folder re-<product>, fix any reported problems, then run build-report.mjs and pack-kb.mjs on the same folder. Expect a passing check, REPORT.html and a zip in the knowledge base folder. Verify that the check reports no failures before packing.

  • Match demo colours and easing to your product stylesheet

    Use the adopt script to copy your app's design tokens into the demo theme.

    View prompt
    In the repo Alexwtlf/agentic-product-demo, run `npm run adopt ../src/app/globals.css --curves --dry-run` and report which tokens matched, which were derived and which are placeholders. Do not write files until the report is reviewed. Verify that no placeholder token appears in the preview stills.

  • Keep two agents from colliding on the same files

    Have agents announce the files they take in the Channel tab and check who wrote what.

    View prompt
    In the project <project>, before editing any file, call chat_post with kind taking and the paths you will change, then call chat_read when you finish. Expected output: a confirmed post and a short list of anything other agents said they were taking. Verify that no other agent has announced the same paths before you start editing.

  • Run a Codex session on a project folder in the browser

    Pick a folder in FCC's browser UI and run Codex there, switching models mid-session.

    View prompt
    Using the repo Alishahryar1/free-claude-code, start FCC, pick the folder <PROJECT_PATH> in the browser UI, and open a native Codex session. Expected output: Codex answers a question about the folder contents. Verify that the answer references files from <PROJECT_PATH>.

  • Flag anomalous fields in data files with a Jev-based CLI

    Find unusual values in selected fields of a data file and review them in local previews.

    View prompt
    Use the jevotron repo (https://github.com/cmungall/jevotron) to flag anomalies in the fields <field-names> of the file <path-to-file>. Return the flagged values with their row references and any local preview paths. Verify that every flagged value matches a field you selected.

  • Split planning, execution, and auditing across models

    Assign a different model or backend to the Manager, Executor, and Auditor of one task.

    View prompt
    Use the LongHorizon-Harness repo at <repo path> to run a task for <goal> with a different model assigned to the Manager, Executor, and Auditor. Expected output: a verified result and a list of accepted checkpoints. Verify that the Auditor inspected the real files or logs rather than relying on the Executor's claim.

  • Add the Old Coder workflow to Codex or Cursor rules

    Paste the Old Coder SKILL.md into AGENTS.md or a rules file so the agent follows the same gates.

    View prompt
    Read skills/old-coder/SKILL.md in the <project-path> repo and follow it for the task <task-description>. Write the SPEC first and wait for my approval, then produce an EVIDENCE report that labels any unverified check as unverified. Verify that references/gauntlet.md was read before the gauntlet ran.

  • Compare LLM serving tools before picking one

    Use the inference module to compare the serving tools the README names.

    View prompt
    From the README of amitshekhariitbhu/ai-engineering-course, extract the inference topics in Module 12 and the tools it names, then build a table for <target workload>. Output the table with topic, tool, and the lesson name, and verify that every tool appears in the README text.

  • Design an AI agent with tools and memory

    Use the agent, tool calling, MCP, and memory sections to scope an agent's design.

    View prompt
    Using the repo amitshekhariitbhu/ai-system-design, read the AI Agents, Tool Calling, MCP, and Memory sections and draft a design for the agent <target>. Output a table of tools, memory layers, and failure modes, each with a test. Verify that MCP is recommended only if the README's When to use MCP criteria are met.

  • Choose a faster decoding method for slow responses

    Compare speculative decoding, Medusa, EAGLE, and n-gram speculation to pick one to study.

    View prompt
    Using the amitshekhariitbhu/llm-inference-engineering repo, compare the speculative decoding methods for the case <case description> and return a ranked list with requirement and trade-off for each. Verify that every claim about speedup in the list is taken from the linked blog posts.

  • Let an agent read and control Chrome tabs with site approval

    Enable the official ChatGPT Chrome extension so an agent can list and control tabs, one approved site at a time.

    View prompt
    Using the amontlabs/lcu repo, enable Chrome control in LCU following the Chrome section of docs/INSTALLATION.md. Ask me to approve one site, then have the agent list my Chrome tabs and summarize the title of the approved site. Verify that no site was accessed before I approved it.

  • Save notes the agent raises when the topic comes up

    Write a reminder once and let the agent bring it back when a chat reaches that subject.

    View prompt
    In OpenGhost from https://github.com/ANDRETRIPOL/OpenGhost, add the note '<note text>' and confirm it appears in the notes list beside the chat. Expected output: the saved note and, in a later related chat, a reply where the agent raises it and asks whether to act. Verify that the agent does not act on the note without asking.

  • Stop an agent from guessing past an irreversible step

    Make the skill halt and name the field when an inferred value touches an irreversible boundary.

    View prompt
    Using the Intent-Router skill in this repo, process the request '<request>' and stop before routing if an inferred value touches an irreversible boundary. Expected output: a HALT decision that names the field to confirm. Verify that no routing or carrying out happened before you answered that field.

  • Map an APK's control flow without flooding the agent context

    Decompile an Android APK to a control-flow skeleton to save tokens during analysis.

    View prompt
    Using the Seep Reverse Lab workspace, triage <path-to-apk> and decompile it with seep_apk_decompile in fold mode. Expected output: a control-flow skeleton listing the main classes and their branches. Verify that the skeleton covers the classes the app's main activity calls.

  • Build a code change with the default full-access agent

    Use the build agent, the default, to make changes in a project after reviewing a plan.

    View prompt
    Using the anomalyco/opencode build agent in <project-path>, implement <change description> and summarize the files you edited. Expected output: a list of changed files and a one-paragraph explanation. Verify by running the project's own test command yourself and reviewing the diff before committing.

  • Check agent tool calls before they run

    Score a proposed tool call against your own allowed options before the agent executes it.

    View prompt
    Using github.com/strands-labs/strands-decider linked from github.com/AnotiaWang/awesome-decision-models, set up the Strands Decider 2B model and score the pending tool call in <tool-call-file> against the allowed actions in <allowed-actions-file>. Expected output: a probability per allowed action and a block or allow decision. Verify that a call outside the allowed list gets a low probability on every option.

  • Run a quick 6-view test on a consumer GPU

    Produce a compact 360 degree six-view set with the Turbo default to check the pipeline works.

    View prompt
    In the 4DAnyone repo, run scripts/download_example.py and then inference.py with --views_per_layer 6 on the example video, writing to <output_dir>. Expected output: six target videos and cameras.json. Verify that videos/ holds 6 .mp4 files and that metadata.json records the run settings.

  • Optimize a single-file algorithm and its description

    Let agents rewrite one .py or .ts file and its description until scores improve.

    View prompt
    Using the AntOmniEvo repo (ant-research/AntOmniEvo), evolve the single-file algorithm at <file-path> and its description, scored by an Evaluator returning 0 to 1. Expected output: the best candidate's file and description plus its change lineage. Verify that the best candidate's score on the validation instances beats the starting file.

  • Export an LDraw model to GLB for Blender

    Convert an MPD model to a GLB file with the local CLI so it can be opened in Blender.

    View prompt
    In the ldraw-nova repository, run ./prepare-glb.sh --file <model>.mpd <model>.glb to create a GLB for Blender. Report the GLB path and file size. Verify that the GLB file exists and that the source MPD was not changed.

  • Handle git workflows with natural language

    Describe a git task in plain words and let Claude Code carry it out in your project.

    View prompt
    In the project at <project-path>, run `claude` and ask it to <describe-git-workflow-outcome>. Expected output: the git steps reported back in the session. Verify by checking the repository state in your own git client or terminal before pushing.

  • Publish existing SKILL.md files as a marketplace bundle

    List skill folders from a source repo in a marketplace entry with strict set to false.

    View prompt
    Using the strict false skill-bundle format in the anthropics/claude-plugins-official README, draft a marketplace entry for the skills at <skill-path> in <source-repo-url>. Output the JSON entry. Verify that every path in the skills array points to a directory containing a SKILL.md file.

  • Post a weekday brief of Slack and GitHub activity

    Deploy a scheduled agent that posts one short brief to Slack each weekday from channels and pull requests.

    View prompt
    Work in the anthropics/claude-quickstarts repository. Open the managed-agents/daily-brief quickstart, follow its README to configure Slack, GitHub and the Claude API key, and apply the deployment files it describes. Report the deployment status and the first brief posted to Slack, and verify that every source is listed as either read or unreadable.

  • Compare the Chinese, English and Spanish editions

    Read the same chapter in its three language versions to check translation consistency.

    View prompt
    In the antinomie-lab/pi-book repo, open the same chapter from agent/, agent/en/ and agent/es/. Output a list of statements where the English or Spanish text differs in meaning from the Chinese original, with the section name for each. Verify that all code citations appear unchanged in all three versions.

  • Run a manager, worker and reviewer team on a scene task

    Split a larger Blender task across a manager, workers and reviewers with ordered steps.

    View prompt
    Using the mcp-for-blender-pro team chain in Blender, run a manager, worker and reviewer workflow to <describe the scene change>. Expect a final summary listing each assignment, its attempt count and the reviewer's approval or findings. Verify that the task board shows tasks completed in order and that no task was left in a blocked state.

  • Find an asset and import it only after approval

    Search Poly Haven for a fitting asset and ask for approval before anything is imported.

    View prompt
    Using mcp-for-blender-pro in Blender, search Poly Haven for an asset matching <description> and wait for my approval before importing. Expected output: a list of candidate assets with names and a single import after approval. Verify that the license of the chosen asset is recorded and that nothing was imported before approval.

  • Index PostgreSQL or MySQL table structures next to the code

    Add a table-level database index so the agent sees both code and schema before it changes either.

    View prompt
    In the repo <project-path>, using the declared PostgreSQL or MySQL source and its connection-string environment variable, build the AOCI database index. Confirm that aoci.database.txt was written and that no credential value appears in any AOCI file.

  • Build the companion from source and audit its claims

    Compile the CLI and desktop app, then check the README's honest boundaries against the code.

    View prompt
    In the Apeireth repo at <repo path>, build the apeireth-cli crate and then search for STUB_MODE and the /v1/ws route. Expected output: a successful release build and the file locations of each match. Verify that the SDK stub and the missing WebSocket route match the README's Honest boundaries section.

  • Install frontier-agent once and launch it in any folder

    Install the command with uv and keep your endpoint settings in one user file.

    View prompt
    Install the FrontierAgent command from the repo at git+https://github.com/ApodexAI/FrontierAgent.git, then start it inside <project path>. The expected output is an open TUI session scoped to that project. Verify that the endpoint settings load from the user config file and that the session starts without errors.

  • Research how top apps structure onboarding and paywalls

    Ask an agent how leading apps in a category run onboarding, what each step does, and where the paywall sits.

    View prompt
    Using the appllama/appllama-skills repo, research how the top-grossing apps in <category> structure onboarding and where they place the paywall, through the Appllama MCP. Output a comparison table with the flow length, the purpose of each step, and the paywall position for each app, and verify each claim against the screens you studied.

  • Measure task time for two local Qwen models on your sites

    Run the same browser task on Qwen3.5-9B and Qwen3.5-35B-A3B and compare task times and verification results.

    View prompt
    In the fast-browser-use repo at <repo path>, run the task <task name> three times each on Qwen3.5-9B and Qwen3.5-35B-A3B. Return a table of task times and whether the final URL and title matched <expected values>. Verify that every run used local inference only before reporting results.

  • Launch a model server from the terminal

    Clone the repo and start the Qwen3.8-27B serve recipe from your command line.

    View prompt
    Clone ARahim3/kaggle-tpu-lab, run `python launch.py serve` to start the default model, and use `python launch.py status` until the server reports ready. Expected output: a running Kaggle TPU session with a public URL. Verify the status output shows the session active before handing the URL to <target>.

  • Prototype a capability in Python, then move it to another machine

    Build a Python plugin first, then swap its location or language without changing its callers.

    View prompt
    Using the repo arcships/rutis, create a Python plugin named <target> with `uvx rutis-host new <target> --lang python`, run `uv sync`, then `uv run rutis-host dev`. Expected output: the host running the plugin. Verify that a caller plugin using the service name still resolves after you change the provider's file.

  • Block new UI drift in CI with a design system check

    Fail the build when a screen stops following the design system's tokens and components.

    View prompt
    In the arla6ka/design.how repo's build-design-system skill, find check-system.mjs, run its --help and --self-test, then add a CI step in <target CI config path> that runs it. Expected output: a passing self-test and a CI step. Verify the step fails on a deliberately drifted screen.

  • Review agent code changes on your phone

    Read git status and diffs, comment on lines, and send the comments to the agent.

    View prompt
    In the arronKler/pairfob repo, use README.md to identify which review features the phone app supports for git status, diffs and comments. Report that list as your output. Verify each item is stated in the 'What you can do from the phone' section.

  • Find every mention of a topic inside one channel

    Search a single channel's videos for a keyword and get the matching videos.

    View prompt
    Using the youtube-skills repo, search inside the channel <channel handle> for the term <term> and list each matching video with its title and URL. Verify one match by opening its transcript and confirming the term appears.

  • Check a setup quickly with the mini replay

    Confirm the tool and server work on a smaller device using the six-turn synthetic replay.

    View prompt
    Using the agentperf-local repo from ArtificialAnalysis, run the aa-mini-v1 replay with --context-tokens 8192 through managed-run on profile gemma4-12b-it-q4-0 and framework llama-cpp. Expect summary.json in results/<name>. Verify the output is marked reduced and state that it is not comparable with full-context results.

  • Export a diagram as SVG, PNG, GIF or MP4 for slides, docs or posts

    Pick the export format that matches where the diagram will be used, from a deck to a README to a short animated clip.

    View prompt
    Use the SeeCode skill from the Aryanutkarsh/SeeCode repo to export <path to diagram> as <format for the destination>. Expected output: one file in that format sized for the destination. Verify that the file opens and that its smallest labels are readable at the size you will use.

  • Run the WikiSkill loop with Claude Code as the agent

    Pin a workspace to the Claude backend and evolve skills using Claude Code runs.

    View prompt
    Using the ashutoshsinghpr7/wikiskill repo, run `wikiskill init demo --backend claude`, then `wikiskill evolve --iters 2`. Report the baseline and final validation scores and the backend in workspaces/demo/workspace.json. Verify that the workspace file names the claude backend before the evolve run starts.

  • Review and correct the agent's memories as plain files

    Open the memory folder to read, edit or version the facts your agent has stored.

    View prompt
    Open the memory folder for the dsh-auto-memory plugin at <memory-folder-path>, list the memory files, and correct the entry named <memory-name>. Expected output: the file reflects the corrected fact. Verify that MEMORY.md still lists that memory and that the next dsh request uses the new content.

  • Map where experts disagree on a topic, as cards

    Get a cited lesson plan and cards that show where practitioners split on a topic.

    View prompt
    Using the Claudemy skill from assafkip/claudemy, ask Claude Code to research <topic> and output the lesson plan and cards. Expected output: a decision-based lesson plan with source agreement counts and cited links. Verify that the cited pages match the claims on each card.

  • Find which sub-agent uses the most tokens

    Read the per-agent ⚡ token counter to see which sub-agent is the expensive one in a session.

    View prompt
    In the repo Atoll92/agent-standup, open the live call for my Claude Code session and list each agent with its ⚡ token count and model. Identify the agent with the highest count. Verify that the figures match the token counts recorded in the session files, noting that they are not an estimate of the bill.

  • Alert when a new executing or secret-holding agent appears

    Save a baseline after review, then fail a scheduled check only when something new can run code or hold secrets.

    View prompt
    On <machine name>, save a baseline with `npx geiger-scan --json baseline.json`, then run `npx geiger-scan --strict --diff baseline.json` and report the exit code and any new findings. Verify that the job exits with code 2 only when a new finding can execute code or hold secrets.

  • Connect Kimi Code to Atria Dawn over Chat Completions

    Add an Atria provider and model entry to Kimi Code's user config.

    View prompt
    Using the atria-asi/Atria-Dawn README, configure Kimi Code 0.43.1 or later to use atria/Atria-Dawn through https://api.atria-asi.ai/v1. Back up ~/.kimi-code/config.toml first, then merge the provider and model blocks. Expected output: a working text reply from Atria Dawn. Verify that default_model is set above the tables and that the context setting is present.

  • Pin a robot moment and test a disturbance

    Use the MuJoCo harness to push a simulated robot and compare the two outcomes.

    View prompt
    Using the MuJoCo harness in the openharness repo, run the robot model <robot-model-name> and pin the moment at <time-in-seconds>. Apply a 100 N push and show the two resulting futures side by side. Verify that the pinned moment is saved and both outcomes are listed.

  • Leave a short handoff note for the next chat

    Save a brief status note so the next Claude Code chat or a teammate can continue.

    View prompt
    In the repo <repo-path>, run /handoff in Claude Code at the end of the session and then start a new chat in the same project. Expected output is a short summary of the open work in the new chat. Verify that it names the same open task you wrote in the handoff.

  • Share project decisions with your team through git

    Commit JEVMEM.md so every teammate's agent gets the same saved decisions and rules.

    View prompt
    In the jevmem-enabled repo at <project-folder>, confirm that JEVMEM.md is tracked by git with `git ls-files JEVMEM.md`. Expected output: the file name printed once. Verify after a teammate pulls that their Claude Code session receives the saved lines on their next prompt.

  • Find out why a run failed and replay it offline

    Inspect one screen with clicker-inspect, then replay a saved run folder without a live screen.

    View prompt
    In the typesafe-computer-use repo, run `uv run clicker-inspect "<goal>"` and then open the saved run folder for the failed run under runs/. Report which action was chosen, what the OCR and accessibility tree showed, and where the decision went wrong. Verify that the annotated screen and payload were produced before drawing any conclusion.

  • Let an agent explore a new codebase without grep

    Give an AI agent a graph of the code so it queries structure instead of searching text.

    View prompt
    In the <repo> project, explore the code needed for <task> by querying the axiomcode graph instead of grepping. Report the functions involved, their file and line, and the number of tool calls used. Verify that each claimed call relationship appears in the graph output.

  • Run release checks before a version tag

    Use Procoder release to catch version drift, a missing changelog entry, and a red test suite before tagging.

    View prompt
    In the procoder-enabled repository at <repo-path>, run `procoder release` and fix every listed failure without tagging. Report the final list. Verify that the tag command is printed only when all checks pass and that you run it yourself.

  • Build a Portuguese legislative text dataset

    Load the curated Parquet release with leakage-free train, validation, and test splits for NLP work.

    View prompt
    Load the Hugging Face dataset BaruqRodrigues/corpus-legislativo-pretraining and report the number of rows in the train, validation, and test splits. Output a table of counts and one sample record per split. Verify that no family_id appears in both train and test.

  • Set one brand palette and reuse shared navigation across screens

    Define tokens once and edit a shared tab bar or sidebar to update every screen that uses it.

    View prompt
    In the Quilt project <project-name>, update the design system with the brand palette <palette> using update_design_system, then edit the shared component <component-name> with edit_component. Report how many screens were re-baked. Verify that the active link is marked correctly on each route.

  • Generate and branch images and video on a Canvas

    Build a node-based image or video workflow on the infinite Canvas using your own BeatAPI key.

    View prompt
    In the BeatDesign repo at <repo path>, use the Canvas to connect a prompt node for <prompt text> to an image generation node, generate three variations, and list the resulting Asset names. Verify that each variation appears as an Asset in the project.

  • Scaffold a motion video project by hand from templates

    Copy the bundled templates into a project folder and follow the pipeline step by step.

    View prompt
    Using the motion-video skill from bestagentkits/motion-video-skill, scaffold a project at assets/videos/<project-name> from the bundled templates and rename the example data and skeleton files as the README describes. Expected output is a project folder ready for the pipeline. Verify that index.html exists and that no API key values appear in any project file.

  • Run a bounded Sponsored Products ad test

    Create a limited Amazon ad experiment and analyze its reports under authorized API access.

    View prompt
    Use the Beyondwords skill from beyondtahir/beyondwords to plan a bounded Sponsored Products test for <book title> with a spending limit of <limit>. Return the outreach plan, the campaign structure for my approval and, after approval, the report analysis. Verify that no campaign is created without my explicit approval and that the spending limit is respected.

  • Replay a retrieval call to audit a bad agent change

    Re-run the exact context an agent received and check which stage surfaced the wrong symbol.

    View prompt
    Using the bgts-context-engine repository, index <target repo path> at the commit <commit id>, then run bce context with the task <task text> and the flag --no-select. Expected output: the byte-exact context pack. Verify by running the same command again and confirming the output matches.

  • Use the API inside a browser translation extension

    Run a local bridge so Immersive Translate can translate web pages through the free API.

    View prompt
    Use the repo at https://github.com/bilibili/Index-Translate. Start the local bridge with `python inference/llm/call_api.py --serve` and confirm it listens at http://127.0.0.1:8080/v1. Return the exact extension settings used. Verify that a test request to that address returns a translated response.

  • Point the harness at your own model endpoint

    Connect the Claude Code harness to a self-hosted Anthropic-compatible model server.

    View prompt
    In the RoboHarness repo, set the model URL and model ID from the environment variables for <model server host>, send the small Messages test request from the README, and then run the task01 dry run. Report the model_url, model, gpu and port values from the dry-run output. Verify that the URL has no /v1 suffix before you run the test.

  • Keep logos and text sharp on a low-poly model

    Use Pixel Match to copy the real pixels of your picture back onto a Pixal3D model cut to about 5k faces.

    View prompt
    Using the AssetFurnace repo at <install folder>, build a Pixal3D model from <picture path> with Pixel Match on and Finish set to about 5k faces. Verify that the text '<visible text>' is legible on the model surface.

  • Track token use in your own Anthropic or OpenAI app

    Wrap your existing API client in one line so optimAIzr can read your app's calls.

    View prompt
    In the optimaizr repo, wrap the API client in <app path> with optimaizr.wrap, run the app once, then run `npx optimaizr` and report the Where it goes breakdown. Verify that the app still returns the same responses it returned before the wrap.

  • Study 20 interactive 3D site patterns for a design brief

    Run the gallery locally and review how each example handles scroll and interaction.

    View prompt
    In the blendi-remade/dioramas repo, read the 20 example rows in README.md and the briefs in docs/briefs/, then list the five interaction patterns most relevant to <product or concept>. Expected output: a table with columns for example name, interaction, and the brief file that describes it. Verify that each example name in the table matches a folder under examples/.

  • Check token usage and cost for a session and its Agents

    Read Pi-native token usage and cost for the current session and its owned Agent sessions.

    View prompt
    Using the pi-herdsman repo, run a task that delegates work to <number> Agents in <project path>, then open the /agents Session stats view. Expected output: token usage and cost totals for the Lead session and its owned Agent sessions. Verify that the totals include each delegated Agent.

  • Copy BoardUI components into an existing Next.js app

    Use the CLI to list, add, and install single components as editable source files.

    View prompt
    In my Next.js project at <project-path>, use the BoardUI CLI from the repo BoardUI/boardui to add the data-table and stat-cards components. Expected output: the component source files copied into the project and a page that renders both. Verify that the project builds without errors after the install.

  • Rank your WeChat chats to choose which ones to review

    List your most active conversations, with one-on-one chats first, before deciding what to summarize.

    View prompt
    Use the greenbubbles CLI from the repo bojieli/greenbubbles to rank my chats with `greenbubbles chats rank`. Return the top 10 conversations with their names and self-message counts. Verify that one-on-one chats appear before group chats in the output.

  • Run unattended CAD edits on a durable headless project

    Create an explicit headless edit key so an agent can revise a server-stored project without a browser.

    View prompt
    Using the headless PartMode edit key in the secret environment, call cad_capabilities, apply the change <change-description> to the server project <project-name>, and export the result as STEP. Report the committed revision and the STEP artifact name, and verify that the revision number increased by one after the commit.

  • Have an agent map a precision problem to the right tools

    Point an agent at the tools index so it proposes a plan for your problem and waits for your approval.

    View prompt
    Read tools/README.md and the tool guides it points to in the bootloops repository. For the problem <describe the integral, dataset, or published number>, propose a plan listing the instruments that apply, or state that none do, with the acceptance test each result must pass. Verify that every tool you name appears in tools/README.md.

  • Pair a Linux machine running agents with your phone

    Install BotBus on a Linux computer and pair it so agents on that box can be followed from your phone.

    View prompt
    On the Linux host, run `botbus pair` and report the pairing status. Then list the tasks BotBus sees on that host, grouped by project, and note any host that is offline.

  • Prepare an AI phone call with a script and guardrails

    Use call-prep to research a callee, set an objective and fallback, and draft a branching call script.

    View prompt
    Using the genspark-claw repo at github.com/breakstageaxe61/genspark-claw, install the call-prep skill and use it to prepare a call to <callee> with the objective: <call-objective>. Expected output: a call plan with objective, fallback, branching script, and guardrails. Verify that the plan includes a fallback path before reporting success.

  • Check what a sandbox forwards before an agent runs

    List the credentials a run forwards by name, and restrict egress if needed.

    View prompt
    Using the brig-sh/brig repository, check the host with `brig doctor`, then run `brig info <sandbox name>` for the sandbox you plan to use. Report the credential names it forwards and whether the network is isolated. Verify that the README says a new sandbox on hvi or Linux gets an isolated network and that Brig refuses a policy-bound run on unsupported backends.

  • Check what an app window shows after each step

    Read a window, act once, then read again to see only what changed.

    View prompt
    Using the macos-harness repo at https://github.com/browser-use/macos-harness, read <app name> with `macos-harness get_app_state`, perform the action in <test steps>, and read the window again. Verify and report only the lines that changed between the two reads, and state whether the expected change appeared.

  • Draw a sequence or data-flow diagram with CJK labels

    Get an agent to size Chinese, Japanese or Korean labels correctly so text stays inside its boxes.

    View prompt
    Using the svg-diagram skill from bybit-exchange/svg-diagram, draw a sequence diagram of <process> with CJK labels in diagram.svg, sizing each label from the CJK width table. Run the linter and confirm 0 errors and 0 warnings, with no text overflow findings.

  • Turn repeated instructions into project notes

    Save the preferences, corrections and facts you keep repeating into a notes file loaded into every new chat.

    View prompt
    Using Claude Code with ctx-handoff-mod, record a repeated instruction for <project path> and then inspect the notes file under ~/.claude/projects/ for that project. Expected output: a Markdown notes file containing the instruction. Verify that the entry appears in the file and in the panel.

  • Make an animated explainer with no paid API keys

    Generate a narrated animated explainer using free Piper narration and Remotion composition.

    View prompt
    In the OpenMontage repo at <repo-path>, produce a 60-second animated explainer about <topic> using only free tools such as Piper TTS and Remotion. Save the final MP4 and verify with ffprobe that the duration is about 60 seconds.

  • Point Codex at a UI element to fix it

    Select an element on the device and attach an instruction with component details.

    View prompt
    Using the callstackincubator/codex-mobile-dev-plugin Mobile Dev plugin, take the annotated element on <device name> with the instruction <instruction text> and apply the change in <project path>. Expected output: the component source edited to match the instruction. Verify the component named in the annotation is the file that changed.

  • Test an agent against prompt injection before it touches real data

    Run direct and indirect injection attacks on a tool-using agent, then add defenses and retest.

    View prompt
    Using the repo calmrocks/ai-engineer-notebooks, run the injection examples in 07-security/01-prompt-injection-and-trust.ipynb against <placeholder agent or tool list>. Expected output: a table of attacks with the tool calls each one triggered, before and after defenses. Verify that the test covers both direct and indirect injection.

  • Reproduce the identifier-fidelity probe experiment

    Rerun the saved Qwen3.8 probe and compare it with the token-count baseline.

    View prompt
    In the canivel/dynolab repo, follow examples/identifier-fidelity-probe/README.md to run the saved probe on the model <model-name>. Expected output: held-out probe metrics next to the input-only control baselines. Verify that your numbers are reported as an exploratory robustness check, not as a validated safety monitor.

  • Check the face crop before a full H3 render

    Use preview output to confirm the crop sits still on the subject before spending a full H3 render.

    View prompt
    Using the repo Carasibana/ComfyUI-H3-FaceRefine, run the H3 Face Track + Crop preview on <video path> without starting a full H3 render. Report the face= value, the lost ranges, and any frames drawn red, and verify that the subject is found on the frames you expect.

  • Use Codex with a local model on your Mac

    Launch Codex against the Slotstream model so code tasks stay on your machine.

    View prompt
    In the carloslfu/slotstream repo, run `slotstream launch codex` from <project path>. Expected output: Codex opens connected to the local model. Verify by asking it for a one-line code explanation of <file name> and confirming it responds.

  • Diagnose why a landing page is not converting

    Load the demand-generation landing-page CRO skill to find the likely causes of low conversion.

    View prompt
    Using the cbrock84/headcount repo, load the demand-generation:landing-page-cro-expert skill and review the page content in <page-copy-file>. Expected output: likely causes of low conversion and the changes it recommends. Verify that each recommendation refers to an element that exists in the page copy.

  • Audit a folder of extracted text for hidden characters

    Scan a whole folder for look-alikes, compatibility characters and invisible characters in one report.

    View prompt
    Using the cjkfold repo, run `cjkfold scan --json <path-to-corpus-folder>` after installing it with pip install cjkfold. Report the number of files scanned, the number of findings per class, and the files with the most invisible characters. Verify that scan exits with code 0 when it only reports findings, as the README describes.

  • Trace why a paper decision card cannot be executed

    Follow the risk, portfolio and quant gates to see which stage kept a paper decision card in a non-executable state.

    View prompt
    In the finathink repo, open the HTML report from a local sample run and list each risk, portfolio and quant stage with its status and evidence reference. Report whether the paper decision card is executable. Verify that the card is non-executable if any upstream stage failed, and state that the repo does not place broker orders.

  • Label each tracked animal's motion state in a video

    Assign stationary, walking, running, or uncertain to every tracked animal in a clip.

    View prompt
    In the JEV_sees repo at <repo path>, with TYPESAFE_API_KEY set, run examples/animal_motion.py on assets/black_cat_walking.mp4. Report frame_index, video_time_s, object_id, and choice for the output; verify that every choice is one of stationary, walking, running, or uncertain.

  • Turn a chat request into a macro on your action bar

    Ask for a macro, click Create macro, and drop it on an action bar from the cursor.

    View prompt
    In the wow-ai repo, with the bridge running, ask the chat agent for a WoW macro that <goal>. Expected output: a reply with a Create macro button. Verify the button is present and that the macro is on the cursor after clicking it.

  • Fold long Claude Code replies to a level you can scan

    Install the TextFold mod so every Claude Code reply shows five levels, from one sentence to full text.

    View prompt
    Using the TextFold repo at github.com/chenxiachan/textfold, install the Claude Code plugin with `claude plugin marketplace add chenxiachan/textfold` and `claude plugin install textfold@textfold`. Expected output: after a reply, pressing 5 shows the answer in one sentence and pressing 1 shows the full reply. Verify that the Full level matches the reply exactly, since nothing is paraphrased.

  • Run profiles on a VPS and view their screens remotely

    Host FoxProfile in server mode and use the web panel to log in or solve captchas on hidden browsers.

    View prompt
    Using the repo chienbm98/foxprofile in server mode on <vps-address>, launch the profile <profile-name> and report whether it is running. Verify that the API answers on port 8000 and that the server refused to start without FOXPROFILE_API_TOKEN set.

  • Let the model fetch only the images it needs with Auto-select

    Keep Auto-select on so earlier images are left out by default and the model asks for the ones it needs by ID.

    View prompt
    Using the repo chipfighter/context-attachment-manager in Codex, keep Auto-select on for the task <task name> and mark <reference image ID> as Send every turn. Ask the model to continue the image work, then list which IDs it requested with need IMG-xxx and confirm that the fetched images are the only earlier ones sent that turn.

  • Track Harness token use and estimated cost on macOS

    Read today and seven-day token totals and estimated cost from the title bar while you work.

    View prompt
    Using the chokwinlee/deepseek-harness-desktop repo, help me set up DSH Desktop on macOS and find the token and estimated cost figures for my current Harness session. Expected output: today and seven-day token totals and an estimated cost. Verify that any model without a public price is shown as unpriced rather than treated as free.

  • Record short gameplay clips of NPCs talking to each other

    Produce 5 to 10 second conversation clips with a fixed gameplay camera and lines rendered first.

    View prompt
    Using the NPCTalk repo at https://github.com/christos-antono/NPCTalk, run the npc-showcase-clips skill to plan a 5 to 10 second conversation between <npc-a> and <npc-b> in <game-name>. Expected output: a planned shot list and rendered line WAVs with timings. Verify that the clip stays within 5 to 10 seconds and that `npctalk check` passes before anything is shared.

  • Approve one exact purchase at a set cap

    Buy a single chosen offer through a one-time signed approval or finish in your browser.

    View prompt
    Using the NorthCinder MCP server, prepare checkout for the offer <offer id> with a spending cap of <amount>, one unit only. Return the approval details, the checkout result or cart link, and the audit log entry. Verify that the merchant, variant, price, and total match the approval before any payment step runs.

  • Deploy an actor to Cloudflare Workers

    Test an actor locally with wrangler, then deploy it to Cloudflare.

    View prompt
    Using the repo clavia-labs/tardigrade, generate a project with `bunx tardie init meeseeks --template quickstart`, add model credentials for <model-provider>, then run `bunx wrangler dev`. Expected output: a local Worker that serves the actor. Verify that both ActorObject and ThreadObject bindings are exported from the Worker entrypoint before deploying with `bunx wrangler deploy`.

  • Find repository files by meaning, not keywords

    Score live repository files and code ranges with Jev probabilities, without an index.

    View prompt
    Use the jegrep tool at github.com/can1357/jegrep on <repository path> with the query <plain-language description>. Report the top ten files and ranges with their probabilities. Verify the top three by reading the code.

  • Classify support messages with a decision model

    Send a message to the PS5 /v1/systemone API to get typed intent and yes-or-no answers.

    View prompt
    Using the cobanov/PS5LM repo, send a POST to http://<PS5-IP>:8081/v1/systemone with a customer message as state and an intent choice question. Expected output is a typed decision with probabilities, and verify that the chosen intent is one of the criteria you supplied.

  • Review agent specs and diffs with an outside reviewer

    Let a reviewer without an account approve a gate through a one-time share link.

    View prompt
    Using the Grasp repo (cocofhu/grasp), review a paused run in <workspace name> and create a one-time share link for its human gate. Confirm the link uses the expected host and report the gate name and its spec summary.

  • Switch off or rewrite rules that never fire or fire wrongly

    Score each rule against your git history, disable the broken ones, and have the agent rewrite the rest.

    View prompt
    In the repo <repo-path>, run `abide report`, then `abide calibrate`, then `abide tune`. Report which rules were switched off or rewritten, and confirm `.abide/rubric.json` still parses.

  • Sweep alpha values to map partial ablation strength

    Run one prompt across several alpha values to see how strength changes the reply.

    View prompt
    Using the repo Continuum-AI-Corp/OrcaBonsai-27B-Uncensored, run run.py on the same prompt with --alpha set to 0, 0.5, 0.7, and 1, using --pack <pack-path>. Expected output: four replies, one per alpha value, arranged in a table. Verify that the alpha value printed or passed matches each run.

  • Try Orca Replay with a sample run and no key

    Run a built-in demo that replays a recorded agent fix without an agent, a key or any model call.

    View prompt
    Use the OrcaReplay repo (Continuum-AI-Corp/OrcaReplay) by running `orca quickstart` in an empty directory. Report the number of failing tests before the replay and passing tests after it. Verify that the output states no model was called and no tokens were spent.

  • Try an agent on your own project in a terminal

    Install Harness UI and run its terminal agent inside a repository.

    View prompt
    Install a13n-harness-ui with `uv tool install a13n-harness-ui`, then run `a13n-harness-ui` inside <your-repository>. Report the model you connected and the execution permission you chose, and confirm the agent can read one file you name.

  • Bring your own AG-UI agent as a Bot

    Connect an agent written in any framework through AG-UI and run it as a coworker with its own channel.

    View prompt
    In the OpenBot repository at <repo-path>, add a new Bot that points at an AG-UI endpoint for <agent-name> following the README's Built on AG-UI and Bots sections. Confirm the Bot appears in /bots and returns a reply to a test message, and report that reply.

  • Correct text in a PDF while keeping the original fonts

    Retype a paragraph inside an existing PDF without covering it with an annotation.

    View prompt
    Using the HermesOffice repo at github.com/criptogus/HermesOffice, edit the paragraph containing <text to change> in <path to PDF> using the true text editing in HermesOffice PDF. Output the saved PDF path. Verify that the corrected text appears and that the original fonts are preserved on that page.

  • Have one agent spawn and coordinate other agents

    Use the built-in MCP server so a lead agent can hand tasks to other agents and read their output.

    View prompt
    Using the diri repo at github.com/cristicretu/diri, have the lead agent spawn helper agents through the built-in MCP server to split <job-description> into subtasks. Output the list of helper agents, their tasks, and their results, and verify that each helper reported an output.

  • Run the wiki as a server that other tools can call

    Start the wiki in Docker and add documents and ask questions through its HTTP API.

    View prompt
    Clone the llm-wiki-v2 repo, start it with Docker Compose on port 8000, then POST the text in <source file> to /ingest and ask <question> through /ask. Expected output: the ingest response and an answer with cited notes. Verify that /health reports the service as running.

  • Call the agent from a shell script with print mode and JSON

    Run one prompt with star -p and --json, then parse the NDJSON output in a script.

    View prompt
    Using the cryer/star-cli repo, write a shell script that runs `star -p "<prompt>"` with --json and writes the output to <output-file>. Verify that every output line parses as valid JSON.

  • Answer questions from your own notes over WhatsApp

    Ingest your notes into a local knowledge base and ask about them from WhatsApp, fully offline.

    View prompt
    In the csr1010/wappy-kit repo, scaffold a project with `npm create @wappy_ai/agent` into ./<project-dir> and choose the local knowledge backend. Expected output: a generated project with a Knowledge/RAG layer backed by SQLite/LibSQL. Verify that the knowledge backend setting in the generated config is local and that no external service URL is required.

  • Pull matching lines from a long or endless web page

    An agent scrolls a feed until a term appears, then returns only the matching lines.

    View prompt
    Using the axuse MCP server, open <page URL>, scroll until the text <search term> appears, then observe only the lines matching that text. Return the matching lines as a list, and check that each line appears in the page when you observe it again.

  • Review a pull request diff grouped by importance

    Render a PR diff as a review canvas so the most important changes are read first.

    View prompt
    Using the pr-review-canvas plugin from the cursor/plugins repo, render the diff for pull request <pr-number> as a review canvas grouped by importance. Output the groups in order with a one-line reason for each. Verify that every changed file appears in exactly one group.

  • Check a run file offline against a key you pinned

    Verify a .tkb run file with only the verifier and a public key, and see a tampered copy fail.

    View prompt
    In the Cygnux-Labs/Tracekit checkout at <repo-path>, run `pip install --no-deps tracekit-ai`, then `tracekit verify docs/sample/demo-run.tkb --key docs/sample/signer.pub` and the same command on docs/sample/demo-run-tampered.tkb. Expect exit 0 for the intact file and exit 1 for the tampered file. Verify that the tampered file's failure points to a specific record.

  • Check that an installed Sure Forge copy matches the source

    Confirm that an installed copy of the skill is byte-identical to the repository version.

    View prompt
    In the Da7-Tech/SureForge repository, run the install verification against <installed skill path> and then the unit tests. Expected output: a pass or a list of mismatched files, and the test summary. Verify that the commands ran from the repository root with Python 3.11 or newer.

  • Prove each change with parallel tests and a source-bound proof

    Run the test gate for a task, queue busy resources and attach proof tied to the frozen code.

    View prompt
    Using the Squadra repo at https://github.com/dagoSte/squadra, prove task <task ID> in the project at <project path>. Expected output: a proof record bound to the current source state. Verify with `squadra doctor --quick` that the registry is healthy before you rely on the proof.

  • Build your own self-improvement loop around evaluate()

    Call evaluate() from your own loop to test each new candidate and feed scores into the next one.

    View prompt
    Using the rsi_eval SDK, write a loop that generates a candidate in <candidate-dir>, calls evaluate() with a new output directory per candidate, and collects per-task rewards. Report the reward for each candidate across iterations. Verify that each evaluation wrote its own result.json and resolved.json.

  • Print a template to get a cleaner handwriting font

    Fill a printable grid by hand, photograph the pages, and build a font with known letter order.

    View prompt
    Use the draw-your-font CLI from the danilo-znamerovszkij/draw-your-font repo to create a template with --charset <charset> and build a font from the filled pages <page-paths>. Expected output is a font file named <font-name>. Verify that the build completes and that the preview shows letters in the expected grid order.

  • Distill a teacher model into a smaller student

    Train a student on its own rollouts using feedback from a teacher model with on-policy distillation.

    View prompt
    Using the miniverl repo (DaoyuanLi2816/mini-verl), follow docs/opd-quickstart.md to set up on-policy distillation with teacher <teacher-model> and student <student-model> on one GPU. Report the path to the exported adapter and the final teacher loss. Verify that the peak reserved VRAM stays within the GPU memory you have.

  • Check OCR results on each page in a local viewer

    Drop in a scan and see lines, blocks, and reading order drawn over the page.

    View prompt
    In the repo datalab-to/indra, install indra-ocr and start `indra-ocr-viewer --port 8765`. Expected output: a local web page at http://localhost:8765 that shows OCR lines and layout blocks for a dropped file. Verify that the page loads and that line confidences are visible.

  • Fine-tune a published EBFM checkpoint with SFT

    Start supervised fine-tuning from a Hugging Face EBFM model using the SFT launcher.

    View prompt
    In the datamllab/OpenEBFM repo, run runs/sft.sh with --finetuning_model_ckpt set to <hf_model_id> and --dataset_name set to <dataset_name>. Report the output directory and confirm checkpoints_hf/ was created.

  • Run Qwen3-0.6B on SGLang on your own GPU

    Follow Part 0.2 to set up the environment and serve a small Qwen3 model with SGLang.

    View prompt
    Clone https://github.com/datawhalechina/zero-to-sglang and follow course-material/eng/part0/Part0-Deploy-Your-First-SGLang-Server.md on the host <gpu-host>. Expected output: an SGLang server running Qwen3-0.6B that returns a completion. Verify the server responds to a single test prompt before reporting success.

  • Back up saved agent chat history

    Copy the core's saved history to a backup location on a schedule you control.

    View prompt
    Using the cloudroom-core repo docs in docs/storage.md and docs/setup.md, identify the saved history folder on <server-host> and copy it to <backup-target>. Expected output: a copy of the folder at the backup target. Verify that the file count and total size match the original.

  • Let a cloud agent read files on your Mac with set limits

    Give a cloud agent access to your Mac at the level you choose: Off, Read-only, Ask first, or Full.

    View prompt
    In the Cloudroom app from the cloudroom-gui repo, set Mac access to Read-only for a cloud thread and ask it to read <file path on the Mac>. Expected output: the file contents reported back, with no edits. Verify that the Mac access level shows Read-only during the run.

  • Find which dashboards break when a column changes

    Use dct impact to list the boards that reference a column before you rename it.

    View prompt
    In the dbt-charts repo, run `dct impact` for the column <placeholder> and list every board that references it. Verify the list against `dct search` results for the same name.

  • Keep a chained record of every agent API action

    Print and store the evidence lines for each intent, decision and forward the gateway handles.

    View prompt
    Using the decionis/agent-safe-pipeline repository, install AgentSafe, run `agentsafe doctor`, and start `agentsafe proxy --upstream <your-api-url> --port 8080 --verbose`. Send one allowed request and one blocked request through the gateway, then list the evidence lines and dossier ids for both. Verify that each request has its own evidence line before you report back.

  • Work an FDE Gym case from the command line with the harness

    Use the Python harness to work a case without the browser workbench.

    View prompt
    In the fde-gym repository at <path>, run `python3 harness/run.py --version` and read harness/README.md. Report the harness version and the exact command the README gives for working a case. Verify the version string comes from the command output, not from the README.

  • Run the Solid Glass site to preview components and blocks

    Start the repo's site locally to browse components, examples and blocks before adopting them.

    View prompt
    Clone https://github.com/deeplethe/solid-glass into <target-folder>, run `npm install` and `npm run dev`, then open http://localhost:5191. Report whether the home page loads and list the components visible on the Blocks page.

  • Connect a coding agent to a knowledge base over MCP

    Give Cursor a scoped MCP connection to a base so it can read dated facts and send proposed changes for review.

    View prompt
    Using the Utopia repo at <repo path>, connect Cursor to the knowledge base <base name> over MCP using a token scoped to that base. Expected output: a dated answer about <entity> as of <date> with identifiers and evidence. Verify that the agent did not write any fact directly, only proposals.

  • Have a coding agent make a change under the repo's rules

    Point an agent at AGENTS.md and CONTRIBUTING.md so its edits follow project guidance.

    View prompt
    In the deepseek-harness repository, read AGENTS.md and CONTRIBUTING.md first, then make <described change> without touching unrelated files. Run `pnpm run build` and report the result and the files changed.

  • Run the Deep Research example to produce an HTML report

    Clone the repo and run a bundled example that researches angles in parallel and builds a report.

    View prompt
    Using the deer-workflow repository (deerwork-ai/deer-workflow), follow examples/deep-research/README.md to run the Deep Research example on the topic <target topic>. Expected output: an interactive HTML report. Verify that the report includes the claims verification step described in the example README.

  • Attach a four-question evidence report to pull requests

    Use the GitHub Action to report what was claimed, what evidence exists, what limits applied, and the conclusion.

    View prompt
    Review the GitHub Action definition at integrations/github/action.yml in https://github.com/dengyier/OpenWorkProof and add it to the pull request workflow of <TARGET_REPO>. Open a test pull request and report the conclusion in the four-question report. Verify that the report does not describe the change as accepted or paid.

  • Let Claude Code edit pictures in Scumble through MCP

    Connect Claude Code to Scumble's MCP server so an agent can select, generate, match and export.

    View prompt
    Using the Scumble repo at https://github.com/DenRakEiw/scumble, connect through its MCP server and select the area <selection description> in the open document, then generate <description of change>. Expected output: a new layer in the open document and an exported file at <output path>. Verify that the new layer appears in the window and that undo reverts it.

  • Feed a diff review as JSON to a coding agent

    Print the change review as JSON so an agent can triage the findings against the code.

    View prompt
    In the jev-review repo, run `npm run review:changes -- <path to git repository>` and capture the JSON output. For each finding, open the cited diff hunk in the target repository and label it as confirmed, unclear, or false positive. Verify the labels by re-reading the code before you change anything.

  • Track AI spend by model and project in one dashboard

    See cost and token use over time, split by model, project and account, on your own machine.

    View prompt
    Using the DevDock-AI/claude-unlimited repo, run a short session with `claude-unlimited code` in <project-path>, then open http://127.0.0.1:4317/ and open the Statistics view. Expected output: charts of spend and tokens split by model, project and account. Verify that the project you used appears in the per-project breakdown.

  • Share agent accounts with a team and track usage

    Pool Claude and Codex accounts, scope them per user, and export usage costs as CSV.

    View prompt
    Use the agentbox repo at github.com/devilcoolyue/agentbox on the server <server-host> to scope the account pool to the users <user-list>. After a test request, open the Usage view and confirm that a record appears with tokens and a price snapshot, then export it as CSV.

  • Build the Chromium 144 fingerprint kernel on Windows

    Compile the pinned Chromium 144 kernel from source with the project's Windows scripts.

    View prompt
    Using the repo DFarm6/Prism-Browser-Community, check the Windows kernel prerequisites in tools/windows-kernel/README.md for a build root of <build root path>. Expected output: a list of required tools that are missing. Verify the build root is a short NTFS path before running the build scripts.

  • Find out why an expected skill was excluded

    Trace where a specific skill dropped out of a ranking and what threshold or setting caused it.

    View prompt
    Using the Dicklesworthstone/skillranker repo, run `sr roster --json` and then `sr rank --context <context file> --allow-network --why-not <skill id> --explain`. Expected output: the stage where <skill id> was excluded, with thresholds and recovery hints. Verify that the trace reports no extra inference calls beyond the original ranking, as the README describes.

  • Compare free-tier capacity before choosing providers

    Check the dashboard's free-tier catalog to see how much usable free capacity you have.

    View prompt
    Using the diegosouzapw/OmniRoute repo, read docs/reference/FREE_TIERS.md and list the free-tier pools it describes for <provider or pool>. Report the monthly budget figures it gives. Verify that you cite the document and do not add figures it does not state.

  • Edit ZCode, DSH or WorkBuddy config files with backups

    View the real config file for another client, edit it inside the app, and keep a backup before saving.

    View prompt
    Using the uni-switch project at github.com/dieqiyun/uni-switch, show the current config path for the client <client-name> and the backup location created before any edit. Expected output: the config path and a backup file name. Verify that the backup exists before saving any change.

  • Record every request to a SQLite log for analysis

    Start the dashboard with a log database so request rows are saved for later review.

    View prompt
    Using the repo DingoOz/llm-visuals, start the dashboard with `cargo run --release -- --log-db llm.db` while a llama-server is running. Expected output: an llm.db file in the repo folder with one row per request. Verify the row count rises after you send a prompt.

  • Attach a terminal to a running agent and steer it

    Reconnect from the terminal to an agent on a device and send it follow-ups or interrupts.

    View prompt
    In the Durable Pi repo at <repo path>, run `just tui attach local` against a running device server. Report the session and agent names shown. Verify that after Ctrl+C the agent is still running by reattaching and seeing its latest transcript.

  • Run each Claude Code session on its own account

    Enrol several Claude Code logins and pick the account for each session at launch.

    View prompt
    Using Session Kit from https://github.com/dob323/session-kit, enrol the Claude Code account <label> with `sp account enroll claude <label> <email>`, then run `sp account list claude`. Verify that the list shows <label> and report the output.

  • Build and modify DomA from its open-source source code

    Clone the repo, build it, and run the dev mode to change how the browser agent behaves.

    View prompt
    Clone the dom-actions/doma repo, install dependencies, and run the build so that the output is in dist/desktop/open. Expected output: a built extension folder and a short note of the build result. Verify that dist/desktop/open exists and loads as an unpacked extension in Chrome or Edge.

  • See what fills the DSH context window

    Install a context dashboard that breaks down window use, compression and token stats per request.

    View prompt
    Using the DSH list at https://github.com/Dominic789654/awesome-deepseek-harness, install the dsh-context plugin from github.com/bowenliang123/dsh-context. Run <task-description> in DSH and report the three largest parts of the context window with their token counts. Verify by matching the totals against the per-request history.

  • Let an agent use your own logged-in browser

    Point the agent at your real Chromium-family browser with your profile and logins.

    View prompt
    Use the bladebro MCP server in real-browser mode to open <site URL> and complete <task>. Return a summary of each action and the final page state. Verify that the account shown is the one you intended before any change is saved.

  • Pull text out of scanned PDF reports

    Let DonSeTch fetch a scanned PDF and run its built-in OCR so the text can be read or searched.

    View prompt
    Using the donsetch MCP server, fetch the scanned PDF at <URL> and return its full text. Confirm the output contains readable sentences from the first page and state whether OCR ran.

  • Run a local AI phone and chat dashboard on Windows

    Install the Windows package to start the local service and open the Tel Agent dashboard in a browser.

    View prompt
    From the Dpro-at/Tel-Agent releases page, install the Windows package for <Windows version> and open the dashboard. Expected output: the dashboard loads in the browser and a first administrator account is created. Verify that the service is running on the local loopback address before entering any provider keys.

  • Drive a native desktop app with a written instruction

    Ask AlphaCode to open a native app, perform steps, and read a result through accessibility APIs.

    View prompt
    Use the dragonked2/alphacode repo's desktop automation to open <application name>, complete the steps: <steps>, and read the result. Report the value read from the screen. Verify the result by comparing it with a value you can calculate yourself.

  • Find the page or file you saw earlier today

    Search the day's record for an excerpt and open the document path or URL it points to.

    View prompt
    In the dragthelake/ambient-context record folder, search the Days files for <placeholder phrase> and list each match with its app, time and any file path or URL. Expected output: a list of matches with timestamps. Verify that each listed path or URL opens the original document.

  • Compare FP32 and quantized state accuracy on long tasks

    Run the evaluation suite to score FP32 against STEP Quant@6 on long-generation benchmarks.

    View prompt
    In the STEPQuant repo at <repo_path>, run the evaluation suite on the long benchmarks for the fp32 and stepquant6 formats of the Qwen model. Report the average accuracy for each format and state whether the stepquant6 score is within 1 point of the fp32 score.

  • Audit a finished world's narrative quality

    Use the developer audit tools to have an LLM review a completed world's story and cognition.

    View prompt
    In the repo https://github.com/dreamscroll-lab/asamana, enable the developer tools and run an audit of type <audit-type> on the world <world-name>. Report the main issues found in the audit report. Verify that the audit ran against a completed world rather than a world still in progress.

  • Test an AI agent's tool authority with security principles

    Apply the zero-trust AI execution principle to each tool call an agent can make.

    View prompt
    Using the enterprise-system-design repository, read principles/cybersecurity/01-zero-trust-ai-execution.md and answer its governing question for <target agent workflow>. Output a list of each tool call the agent can make with the fresh, target-bound capability it needs. Verify that no tool call appears without a named capability check.

  • Check Wu's memory use against your current editor

    Read the memory benchmark and measure your own setup before moving a machine to Wu.

    View prompt
    Clone the dstrml/wu repo and read docs/memory-benchmark.md. Expected output: a short summary of how the benchmark measured memory and which editors it compared. Verify that the summary names each editor compared.

  • Import GitHub issues as board cards and track them

    Pull open GitHub issues into the kanban board and assign them to agents.

    View prompt
    In the dualface/kander repo, use the GitHub integration to import the open issues from <owner/repo> as task cards. Report how many cards were created and their IDs. Verify that each card links back to its source issue.

  • Triage a binary by strings, patterns, and references

    Use an AI assistant to scan a loaded module for strings, byte patterns, and call or jump references.

    View prompt
    Using the x64dbg-MCP-Server tools at http://localhost:9094/ with my Bearer token, run GetStrings and FindPattern with ?? wildcards on <module name>, then GetReferences for <target address>. Report the matching strings, pattern hits, and callers. Verify that each reported address falls inside the module range from ListModules.

  • Check which files a search will send before running it

    Count the files under a root and exclude paths so only intended source reaches the provider.

    View prompt
    For the repository at <target path>, run `jg files <target path>` and summarize the file counts by top-level directory. Then propose `--exclude` patterns for generated or sensitive paths and confirm the counts drop before any search is run.

  • Create an engineering drawing from a CAD model

    Ask your agent to turn a generated 3D model into an engineering drawing.

    View prompt
    Using the text-to-cad plugin from https://github.com/earthtojake/text-to-cad, generate an engineering drawing from <model file path>. Return the drawing file path and list the dimensions it shows so I can compare them with the model.

  • Post a finished video to social accounts safely

    Dry-run and then schedule a passed ReelMimic video to TikTok, Instagram and YouTube via Upload-Post.

    View prompt
    In the reelmimic repo app folder, run `npm run post-video -- --platforms <platforms>` as a dry run for the project <project name>, then review the listed output. Expected output: a dry-run summary of what would be posted, with nothing sent. Verify the output before adding --send, and only send if the project's final review passed.

  • Rewind a Git-backed agent task to a checkpoint

    Roll an agent's Git-backed work back to an earlier conversation point when a change goes wrong.

    View prompt
    In the waku app, open the Git project at <project path>, run an agent task called <task name>, and rewind it to the checkpoint <checkpoint name>. Expected output: the project files and conversation match the checkpoint. Verify with `git status` in <project path> that the working tree reflects that earlier point.

  • Find z-fighting and floating parts, then export to Roblox

    Have an agent check a model for z-fighting, floating parts and bad normals before exporting it to Roblox.

    View prompt
    Using the blender-skills repo, check <model file> for z-fighting, floating parts, bad normals and bad weights, fix what it finds, then export it for Roblox. Expect a QA list before and after the fixes and the exported file. Verify that the second QA pass reports no remaining issues before the export runs.

  • Find out why an LLM call failed or cost too much

    Read the route, status, tokens and cost of any request in the request log.

    View prompt
    Using the eliasbiondo/antirion README, find the request in the Request log that matches <request description> and report its status, Model, key, tokens, latency and cost. Expected output: a short summary of that request. Verify that the reported values match the request details in the console.

  • Scout new bot listings on a schedule without rereading the full feed

    Check the small updates feed on a schedule and surface only listings you have not seen.

    View prompt
    Fetch https://botdirectory.ai/updates.json and compare its listing identifiers with the seen list in <seen-file>. Output only the new listings with name, integrations, and detail URL, then write the updated seen list back to <seen-file>. Verify that no identifier appears twice in the seen file after the run.

  • Give a bot access to apps through MCP or OpenAPI

    Add your own HTTPS MCP server, Treg endpoint, or OpenAPI document as a tool source for a bot.

    View prompt
    In the Rakazo repo at https://github.com/elie222/rakazo, use the Integrations area of a running instance at <instance-url> to add the HTTPS MCP server <mcp-url> as a tool source. Report the tool source name and one tool it exposes. Verify that a test bot request uses the tool and returns a result.

  • Reset and switch simulation scenes from the terminal

    Use the terminal interface to reload the environment or pick a different scene without restarting.

    View prompt
    In the EMERGE-Policy repo, open the TUI with `emerge` and run `/scene` to select the scene named "<scene>", then run a task. Expected output is the selected scene loaded with plan and robot state shown. Verify that the scene name in the interface matches the requested one before continuing.

  • Add or fix a phone UI translation

    Edit one text file per language and rebuild, so a native speaker can correct a draft UI language.

    View prompt
    In the AIKON repo, edit app/lang/<code>.txt to correct the translations I provide, then run `make -C app langs`. Expected output is the coverage report for that language and no build errors. Verify that every English line still has exactly one TAB-separated translation.

  • Install one skill or MCP server for many harnesses

    Add a SKILL.md or remote MCP server once in Settings and use it across supported harnesses.

    View prompt
    Using the repo emo-xiaoyu/harness-mix, install the skill at <path to SKILL.md> at Global scope and register the remote MCP server at <server URL>. Report the install location for each harness and confirm that the skill is listed in one harness session.

  • Run a paced batch of social Reel B-rolls

    Queue several Reels, pull the next item at a set pace and close each one when done.

    View prompt
    Using the get-brolls repo, enqueue the Reel projects listed in <batch file> and process them one at a time with the queue command. Expected output: a queue status showing each item as done or failed. Verify that a failed item does not stop the rest of the batch when --continue-on-error is set.

  • Block force pushes to main with a pre-receive hook

    Write a pre-receive hook that rejects ref updates which would overwrite main.

    View prompt
    In the enroute-sh/enroute repository, read docs/reference/hooks.md and write a pre-receive hook in <app-dir> that rejects non-fast-forward updates to main. Expected output: a hook handler that returns a rejection for those updates. Verify by force pushing a test commit to main and confirming it is rejected.

  • Share a session map without prompt text or file contents

    Build a path-redacted map and export one session as a file that carries no prompts or file contents.

    View prompt
    In the agentplay repo at https://github.com/Entelligence-AI/agentplay, rebuild maps with `--path-mode dirs_only`, then export the session <session id> to <output file>.json. Report the repo names and the number of paths the export tool says it contains. Verify that the exported file has no prompt, assistant, or tool output text.

  • See which coding agent is using which simulator

    Track Claude Code and Codex device calls per session and claim devices so agents stop colliding.

    View prompt
    Using the simfleet repo (entropyconquers/simfleet), run `simfleet agents` from inside a Claude Code or Codex session in <path-to-app>. Expected output: the live agent sessions and the devices they have touched. Verify that after `simfleet claim <device-id>` the device is listed as held by this session.

  • Rebuild the store in Blender and render a shopper's view

    Calibrate the camera to marked corners, model the fixtures in Blender and render one shopper's view.

    View prompt
    Using the repo escudero/brandpose, follow docs/experiments/2026-10-18-blender-pov.md to calibrate the camera with scripts/blender/calib.py, then render the shopper's view with scripts/blender/pov.py for <person ID>. Report the output video path and the calibration result. Verify with scripts/blender/overlay.py that the fixtures match the image before accepting the render.

  • Build with Opus through Claude Code, then check in Codex

    Let Opus implement a whole assignment, then have the Codex host verify it in the browser.

    View prompt
    With the codex-on-crack package in <project folder>, have Opus 5.5 implement <assignment> through Claude Code, then ask the Codex host to open the result in the browser and report any problems. Expected output: the implementation plus a browser check summary. Verify that the browser evidence comes from the Codex host, not from the Claude session.

  • Map AI-for-games research across six lifecycle roles

    Use the six-role structure and survey map to plan a research or product review.

    View prompt
    Using the Eurekaleo/awesome-ai-for-games README, summarize the six research roles described in the About the survey section and name the role that covers game testing or support. Verify that your summary uses only the role names and descriptions given in the README.

  • Build a private skill corpus from your own registry

    Run the Skill Corpus pipeline on your own source registry, applying curation, safety, and license gates.

    View prompt
    Clone https://github.com/EverMind-AI/SkillCorpus, configure the aggregate step with the source registry at <registry path>, run the build command in skillcorpus/cli.py, and report the exported corpus path and skill count. Verify that the export contains skills.parquet and the dataset card.

  • Check the harness tests before editing it

    Run the repo's test suite and lint hooks to get a clean baseline before changes.

    View prompt
    In the facebookresearch/swe-sweep repo, run `uv sync --extra test` then `uv run pytest` and report the pass and fail counts. Confirm that `uvx pre-commit run --all-files` passes before making any edits to <file-to-change>.

  • Find failing and slow tool calls in an agent run

    Filter a session for reported errors and long durations, then review heuristic patterns.

    View prompt
    Using the TraceCrate repo at <repo path>, start the dev server and load <session file path>. Expected output: a Timeline filtered to reported errors or events above a chosen minimum duration, sorted longest first. Verify that events with missing duration are excluded when a minimum is set, and that heuristic flags are treated as hints, not confirmed causes.

  • Check that output stays identical across memory presets

    Run the same prompt on a small and a large preset and compare the generated text.

    View prompt
    In the repo FareedKhan-dev/kimi-k3-in-c, run the same prompt with the laptop preset and the server preset, using --incremental. Expect two generated text blocks with timing lines. Verify that the generated text is byte-identical between the two runs.

  • Keep a remote terminal task alive on a weak network

    Use Mosh with a tmux session so long-running commands survive phone sleep and network changes.

    View prompt
    Using the farlume/termish README, describe how to set up a Mosh connection to <host> that starts the command `tmux new -A -s main`. Expected output: a checklist covering mosh-server, UDP reachability and the startup command. Verify that the checklist includes the note that tmux or Mosh is needed for terminal continuity.

  • Critique an existing brand identity with measured checks

    Get contrast, colour-blindness, glyph and licence checks on a logo, type and palette you already use.

    View prompt
    Using the repo fatihaydost/brand-identity-skill, critique the existing identity described in <files or description> and report contrast (WCAG 2.2), colour-blindness, glyph coverage and font licence results. Expected output: a critique that separates failed measurements from warnings and judgement. Verify that each failed measurement names the colour pair or font it refers to.

  • Turn a failing Playwright test into a bug-report video

    Create a narrated film of the failing steps plus a Markdown summary for the issue.

    View prompt
    Using the showtime skill in the FavioVazquez/showtime repository, run `showtime repro` on the Playwright trace for <failing test>. Expect a narrated film and a Markdown summary in showtime-out/. Verify that no typed values appear in the film or the summary.

  • Review all nine robot states before choosing a design

    Look through the playground to pick a shape and state set before writing any code.

    View prompt
    Open https://robot-heads.fayaz.workers.dev and list the four shapes and nine states from the robot-heads README. Expected output: a table that maps each agent event in <product description> to one state and one shape. Verify each state name matches the README exactly.

  • Add a new lab to the Discover AI app

    Generate a lab folder with the project script, then run the checks before opening a pull request.

    View prompt
    In a local clone of Fazmin/AILearningGuide, run npm run new:module -- <lab-name> and then npm run check:modules. Expected output: a new folder under src/modules/<lab-name> and a passing module check. Verify that npm run check reports no errors before any commit.

  • Keep logins and cookies between agent browsing runs

    Store the browser profile in a folder so the agent stays signed in to sites after a restart.

    View prompt
    Using the invisible-playwright-mcp server from feder-cr/invisible_playwright_mcp with a profile directory set to <profile-folder>, open <site-url> and report whether the account page loads without a login prompt. Expected output: a yes or no with the page title. Verify that the profile folder now contains the session data after the first run.

  • Diagnose a motion video that reads like a slideshow

    Run the continuity check on an existing motion video to find the cuts where nothing carries over, then fix them.

    View prompt
    Using the onetake skill in the feitangyuan/onetake repo, run the continuity check on <video file or source> and list every boundary where no element carries into the next beat. Output the failing boundaries with a carry score for each. Verify that the score is higher after you apply the proposed fixes.

  • Trace decisions and conflicts across meeting notes

    Build a knowledge graph over meeting notes to follow relationships, sources, and conflicting facts.

    View prompt
    Using the FengZhenfei/carrel search API at http://127.0.0.1:9810/search, ask about how <decision topic> changed across the meeting notes, and follow graph relationships when more evidence is needed. Return a dated timeline with sources and mark any conflicting facts. Verify that each dated item links to a source passage.

  • Ask an AI agent questions over dated filings

    Connect an MCP client to Qanat's read-only research scope and query SEC filings and screens in plain language.

    View prompt
    Using the qanat MCP server in <project-folder> with research scope, answer this question: <question>. Reply with the answer, the source filings or tables used, and the dates they were public. Verify that every number comes from a Qanat tool call and not from memory.

  • Get a verdict on every open PR before merging

    Run a reviewer loop that checks open PRs against their Linear issue and required checks, then posts a verdict.

    View prompt
    In the GitHub repo at <repo path>, run /loop /finn-review on the open pull requests. Expected output: a three-group verdict posted on each PR with its Finn-loop label. Verify that each verdict names the linked Linear issue and the required checks it was measured against.

  • Share one plan across several repos with Stores

    Keep cross-repo specs in a separate shared repo that code repos and agents can read.

    View prompt
    Using the Stores guide at openspec.dev/docs/stores for Fission-AI/OpenSpec, set up a planning repo at <store-path> with the openspec/ shape of specs and changes. Expected output: a committed store containing one cross-repo change folder. Verify that the change folder is present and pushed with git before any code repo is modified.

  • Test Posthorse in one Pi session before installing

    Load Posthorse for a single session to check rollover behavior without a permanent install.

    View prompt
    Using the pi-posthorse repo (fitchmultz/pi-posthorse), start a single Pi session for the project at <project-path> with `pi -e npm:pi-posthorse`, run a long task, and report whether a new_context request or a Compacted card appears. Verify that pi list does not show a permanent install if the developer asked for a one-session test.

  • Check a workstation for viewer and driver problems before a robot session

    Run the built-in doctor command to find setup problems in plain language.

    View prompt
    In the Flaminis/Dalaran repository, install the dalaran-cli binary and run dalaran doctor on this machine. Expected output is a list of findings about build info, graphics adapters, and environment variables. Verify that the report names no failing item before the robot session starts.

  • Build a review inbox where humans approve agent actions

    Combine Decision Inbox, Email Draft and Comment Thread so people can approve or discard agent output.

    View prompt
    Install the decision-inbox, email-draft and comment-thread items from https://www.affectui.com/r/<name>.json into the <project-path> React 19 project, then build an approvals page in <page-file> that passes pending agent items into them. Expected output: one page that renders all three components with your data and event handlers. Verify that answering a decision and discarding a draft each call your handler once.

  • Have two agents on one machine agree a work split

    Let a Codex session find a Claude Code session on the same repo and message it directly.

    View prompt
    Run `flopwire peers` in the flopwire/flopwire context and list the live sessions on this machine. Send <message text> to the session <session-id> with `flopwire send <session-id> -- "<message text>"`, then confirm the send by checking `flopwire messages` for the outgoing message.

  • Import a Cursor transcript as a paused handoff

    Turn a copied Cursor chat transcript into a paused Capsule that you review before acting.

    View prompt
    Using the Frankie-Xu/threadport repo built with Node 24, extract a transcript-only Capsule from <cursor-transcript-file> with --from cursor and write it to <output-path> outside the project. Report the status field and confirm that files, commands, tests, failures, completed, and decisions are empty.

  • Calibrate a physical robot link in safe steps

    Set motor limits and send commands to a lifted robot only after dry-run checks pass.

    View prompt
    In the flybrain-robot-bridge repo, copy config.example.yaml to config.yaml and set robot_ip, pc_port, robot_port and motor limits from the values I give you for <robot-ip>. Run the dry-run checks first and report the output. Do not run with --send unless I confirm the robot is lifted and the power cutoff is in place.

  • Point at the right browser tab out of many

    Raise a Chrome window and point at one tab by its title.

    View prompt
    Use the bigarrow CLI from franzenzenhofer/big-arrow-on-the-screen to raise the Google Chrome tab titled "<tab title>" and point at it with the sign "<sign text>". Expected output: the tab is selected and the command exits with code 0. Verify the exit code and report the tab title that was selected.

  • Check if a harness score is comparable before citing it

    Confirm the egress policy and comparability flag before you put a new score next to published ones.

    View prompt
    In the frontier-harness-eval/eval repo, read metadata/harness-versions.json and results/eval-data.json, then open the run.json in <run folder>. Report the egress_policy mode and whether methodology_comparable is true or false. Verify that the flag is false unless a matched control run is recorded.

  • Compare local decision models with stuntdouble

    Use the independent stuntdouble companion to import JevBench public hard items and compare local models.

    View prompt
    Read the stuntdouble project at github.com/ReallyArtificial/stuntdouble and import the public hard items from github.com/fstandhartinger/jevbench (datasets/public/hard.jsonl) to compare <list of local decision models>. Output a table of results per model and a note that these are not official JevBench results. Verify that the import used only the public split.

  • Print a session's agent tree without opening the TUI

    Dump the session tree to the terminal headlessly for logs, notes or scripts.

    View prompt
    In the zoetrope repo (furkankly/zoetrope), run `zoe inspect` on the session file at <session-file-path> and save the output to <output-file>. Expected output: a printed session tree with the main session and its subagents, written without starting the TUI. Verify that the output file is not empty and lists at least the main session before reporting success.

  • Pull feeds for a topic from the JSON catalog

    Have an agent read data/feeds.json and list feeds for a chosen bundle with their feed URLs.

    View prompt
    Read data/feeds.json from the fuxiaoai/tidings-rss repo and return every feed whose bundles include <bundle-name> as a JSON list of name and feed URL. Verify that the count matches the bundle size shown in the README table for that bundle.

  • Set up FuXi on a headless machine with a setup token

    Authenticate FuXi on a server or CI runner without an interactive sign-in using a setup token.

    View prompt
    On the headless host <host-name>, install FuXi from the fuxicodex/Fuxi repo and authenticate with `fuxi setup-token`. Expected output: `fuxi doctor` completes its environment checks without errors. Verify by running `fuxi --version` and confirming the version prints.

  • Let an AI agent pull IDX stock briefs over MCP

    Expose Idx as MCP tools so an agent can answer questions about IHSG stocks with live tool calls.

    View prompt
    Connect to the idx MCP server from the fzn0x/idx repo and call idx_brief for <ticker such as BBCA>. Summarise the quote, verdict, returns against IHSG, top holders and headlines in plain language. Verify that the answer quotes the last trade time from the tool result and says the data is delayed.

  • Remove or replace one object without touching the rest

    Paint over an area, pick Remove or Replace, and let the model edit only that region.

    View prompt
    In the Kokon app, remove the object at the painted area of <photo path> and save the result as <output path>. Expected output: a new image file with the same size as the source. Verify by comparing the unpainted parts of the source and result images to confirm they are unchanged.

  • Add a custom URL lookup action to the popup

    Create an extension folder with one Openclip.json file that sends selected text to a search URL.

    View prompt
    In the OpenClip repo at https://github.com/ganeshmshetty/openclip, create ~/.openclip/extensions/<identifier>/openclip.json with one url action whose url contains {query}. Expected output: the file exists and is valid JSON, and the action appears in the popup for selected text. Verify the JSON parses before testing it in the popup.

  • Check a figure zoomed in, in both themes and at phone width

    Run the repo's capture and audit scripts on a finished figure before publishing it.

    View prompt
    In the Garinmckayl/anima repo, run the capture script and the bio-audit on the built figure in <figure-folder>, then report each audit issue with its location. Expected output: captured screenshots in dark and light themes plus a list of audit findings. Verify that the audit reports no unresolved membrane intersections, label-target problems or undeclared scale.

  • Build beat-synced motion graphics for a short video

    Use BeatGrids and LayerAnimation to time text and shape motion to the beat of a music track.

    View prompt
    In the framefields repo, build a composition that places text from <lyrics or headline list> on the beats of <audio file>, animating each entrance with LayerAnimation, and render it to output/<name>.mp4. Expected output: an MP4 whose text moves start on beat frames. Verify by checking the BeatGrid timestamps against the keyframe start frames.

  • Remove Fire TV preloaded apps without a new launcher

    Disable preloaded Fire TV apps over Wi-Fi. The home screen stays as Amazon ships it, because Fire OS will not hand Home to a third-party launcher.

    View prompt
    Using the Gathin23/cleanyourtv repo as context, debloat the Fire TV at <tv-address> on the local network by disabling only the preloaded packages I approve with pm disable-user. Expected output: a backup of the package list and a list of disabled packages. Verify that the Fire TV home screen still loads and that no package was uninstalled.

  • Batch-create several distinct poster concepts at once

    Delegate five different poster designs and generate them in one bounded parallel run.

    View prompt
    Using GPT Image Skill in <repo path>, create <number> distinct poster concepts for <campaign brief> at <aspect ratio>. Expect one PNG per concept in /generated-images, each with its own filename. Verify that the prompts differ in composition and not only in wording.

  • Find the office file that answers your question

    Search your work folder by names, folders and full text, with optional Jev reranking of the top hits.

    View prompt
    In the GenOffice app, search the work folder <folder path> for documents that answer '<question>' and turn on Jev reranking if a key is set. Expected output: the top five files in order. Verify that the first file contains the answer by opening it.

  • Add a company and its tools to the catalog

    Open a pull request that adds a company file and its tool files, checked by pnpm.

    View prompt
    In the growth-engineer repository, use the research-company skill to add a company file and its tool files for <vendor>, citing the vendor's own documentation for each tool. Run pnpm content:check and report the result, and do not finish until it passes.

  • Watch pool quota, cooldowns, and plans in real time

    Open a live terminal monitor that shows in-flight requests, account states, and quota windows.

    View prompt
    In the underclass repo at <repo path>, with the server running, start `underclass top` and capture the account table. Expected output: one row per configured account with a status label and plan. Verify that each cooling account shows a reset time and that the PLAN column is filled or marked unknown.

  • Share a tested bot with a teammate by code

    Export a bot's settings and instructions so a teammate can import the same bot.

    View prompt
    Using the gitbot-hq/GitBot package, export <bot name> with Share with code and import it on a second machine with Import bot. Expected output: an imported bot with the same instructions and permissions and no chat history. Verify that the agent named in the bot is installed on the second machine before the first thread runs.

  • Harden a customer-facing agent before launch

    Review an agent for reliability and prompt injection using listed guidance and tools.

    View prompt
    Using the 12-factor-agents and snyk/agent-scan repos listed in global-fde/awesome-fde-resources, review the agent at <agent path or repo>. Produce a checklist where each principle or finding is marked pass, fail, or not tested. Verify that you scanned only targets the owner authorized.

  • Route an OpenAI-compatible client through the gateway

    Change one base URL so an existing client gets Semantix caching with no code change.

    View prompt
    Using the Gnosil/semantix repo, point <client> at semantix-gateway by changing only its base URL, then send <N> similar requests. Report the cache token counts returned by the provider for each request. Verify that the client code and request bodies were not changed except for the base URL.

  • Evaluate the frozen controller on a text benchmark

    Run the released controller on a fixed text reasoning split with its backbone.

    View prompt
    In the repo GongZhiren/State-of-Thought, install the package, prepare data as described in data/README.md, then run sot data validate and sot evaluate with experiments/paper/<backbone config>.yaml. Report the validation result and the evaluation summary, and confirm the checkpoint identity recorded in the summary matches the released one.

  • Assert phone flows inside a pytest suite

    Call ARTEMIS from Python and assert on the result in an existing test suite.

    View prompt
    In the google/artemis repo, write a pytest test that uses artemis_client.ArtemisClient to run the instruction: <instruction> on device <device_serial>. Expected output: a passing pytest result when the task succeeds and a failure message containing result.error or result.status when it does not. Verify the test calls client.run and asserts result.succeeded.

  • See what depends on a function before you change it

    Build the code graph and list the code that depends on a symbol before you edit it.

    View prompt
    In the Graphicle-AI/graphicle repository's code graph, run `graphicle graph extract . --code-only` in <repo-path>, then `graphicle graph affected "<symbol>()"`. Expected output: a list of code that depends on the symbol. Verify by opening two listed dependents and confirming they call or import the symbol.

  • Export a JSON audit report for team review

    Produce a machine-readable JSON file from one or more MCP configs for scripts or tickets.

    View prompt
    Use the GitHub repo graygnatconsole/mcp-audit-tool to run `mcp-audit scan <config-path> --format json --output report.json` on <config-path>. Return a summary table of findings grouped by severity. Verify that report.json exists and parses as valid JSON before summarizing.

  • Capture a hard-won lesson as reviewed memory

    Turn a debugging finding into a scaffolded memory that goes through normal code review.

    View prompt
    In the repository grpcer/ownmem, scaffold a memory named <memory_slug> with `npx ownmem new <memory_slug>`, then fill in the cause and the fix from <the debugging session>. Expected output: a new .ownmem/<memory_slug>.md file that passes the gates. Verify that `npx ownmem recall -- "<a phrase from the memory>"` returns it with an advisory trust line until evidence is attached.

  • Archive a Flow project's media locally at no cost

    Download existing images, clips and stitched films from Flow, including 1080p upscales, without regenerating.

    View prompt
    Using the flow-mcp repo at <repo-path>, list the assets in the open Flow project and download all videos and images with the free download tool, including the 1080p upscale where available. Expected output is local media files in ~/flow-mcp-out/ with one stitched film per scene. Verify that the credits remaining shown by flow_status did not drop during the download.

  • Make a vertical social short that works without sound

    Create a 45 s to 3 min vertical short with hook frames reviewed first, using the social-short pipeline.

    View prompt
    Using GTKottman/mortiflix-oss, create a social-short project for <your topic> with `mortiflix new social-short` (inferred command). Run `mortiflix run` and report the first gate. Verify that the first review is the hook frames and that the output is vertical.

  • Strip AI marks from files inside a Codex project

    Install the full skill into one project and call the local service from Codex.

    View prompt
    In Codex, use the remove-ai-marks skill from the watermarks-remover repo to inspect <file path> through the local service at http://127.0.0.1:8765. Report the provenance marks found, then clean the file and report whether a second inspection shows none.

  • Cut a YouTube video or podcast into vertical shorts

    Clip the best moments of a long video into vertical shorts with the speaker's own voice.

    View prompt
    Using the khan-explainer clip pipeline, find the strongest moments in <video URL> and render vertical shorts in light and dark themes. Expected output is a set of vertical MP4 clips with the speaker's audio. Verify that each clip's audio and board drawing stay in sync using the contact sheet.

  • Review agent access and audit in the control room

    Open the console to check access, policies, conflicts, and audit events across agents.

    View prompt
    In the halofy repository, go to kernel, run npm run serve, and open http://localhost:8787/console/login. Report which sections of the control room are available, and verify that the audit section lists recorded events after one write has been made.

  • File incoming documents from a folder automatically

    Point an agent at a folder with a rule, so new files are handled the moment they land.

    View prompt
    Using the Bloks repo at hamedgitty/bloks, set up a watcher on the folder <incoming-folder> that files new invoices into <filing-folder>. Expected output: a watcher entry plus a change card for each filed file. Verify that the first look only created a baseline and that the first real file was filed as your rule says.

  • Set a spending budget and get warned before you go over

    Track budget used percentage and today's share of budget, with warnings at 80 percent and over-budget at 100 percent.

    View prompt
    Using the dsh-cost-meter plugin in DeepSeek Harness 0.2.0 or later, read the current budget used percentage and today's cost against the budget limit, and say whether the warning or over-budget state applies. Verify that the figure matches the budget box in the sidebar.

  • Connect the cheapest API to your coding agent

    Store a key hidden in your terminal and let Grandet write a backed-up config change to your agent.

    View prompt
    Using the Grandet Skill connect program for <app name, for example Codex or Claude Code>, connect the chosen API for <model name>. Show the configuration change before writing, confirm the backup was made, and report the result of the key, group and model name check.

  • Draw orb geometry in SpriteKit, Metal or another surface

    Read the public frame data and render it in a non-SwiftUI target.

    View prompt
    Read the Draw it yourself section of the ThinkingOrbs repo (https://github.com/haplollc/ThinkingOrbs) and write a <target renderer> function that draws OrbDesign.<design>.frame(size:at:) lines then dots. Return the drawing code and confirm that the output contains the same number of dots as the frame.

  • Boot a local LLM on a Raspberry Pi 5 from SD

    Build a Pi 5 NightRun image with a Llama or Granite model and boot it from a microSD card.

    View prompt
    Use the repo hardrave/NIGHTRUN to build a Raspberry Pi 5 image at models/model.nrm for the target <target> (a whole-disk microSD device). Expected output: nightrun-pi5.img built with cargo xtask pi-image and written to the card. Verify that the device name matches <target> before any write step runs.

  • Make images and videos with sound on your own box

    Run Qwen-Image 2.1 and MiniMax-H3 locally from the cockpit, with one Load button.

    View prompt
    Use the repo hasso5703/dgx-spark-qwen38 on a DGX Spark to load the Qwen-Image 2.1 lane and generate one 1024x1024 image from the prompt <prompt>. Expected output: an image file produced locally in about the time the README reports with Turbo. Verify that the image is written on the box and that the cockpit shows the lane loaded.

  • Route any OpenAI-compatible client through a local proxy

    Start Headroom as a local proxy so existing tools shrink traffic without code changes.

    View prompt
    Using the repo headroomlabs-ai/headroom, start `headroom proxy --port 8787` and configure the OpenAI-compatible client in <client-config> to use http://localhost:8787 as its base URL. Expected output: normal responses and savings shown in the dashboard. Verify that a test request returns a valid answer.

  • Read Claude's Mermaid charts and math as drawn cards

    Turn Mermaid fences and TeX math in replies into charts and typeset cards you can copy.

    View prompt
    In Claude Code with hellosverre/claude-skins installed, ask Claude to explain <topic> with a Mermaid flowchart and a short formula. Expected output: the flowchart appears as a chart card and the formula as a typeset card. Verify that the Copy button is present on each card.

  • Measure how often answers flip when options are reordered

    Test whether a decision model gives the same answer when option order changes.

    View prompt
    In the repo openJev-verdict-2.0, read the Symmetric Permutation-KL section and the evaluation script at verdict2/evaluate.py. Write a script that shuffles option order for each decision in <decision file> and reports the percentage of answers that flip. Expected output: a flip rate percentage, and verify that the script reports the same option when the input order is unchanged.

  • Write a serial story with the story engine

    Enable 故事工程 to keep an outline, foreshadowing, and character knowledge in sync across chapters.

    View prompt
    In the repo hewzhew/dsh-agent-rp, read docs/story-engine.md and set up a story project following it for <story-title>. Report the outline sections created and confirm that character private knowledge is kept separate from public history. Verify that the saved events match the final passage.

  • Show pixel art instead of the step log while Claude works

    Use the textless desktop app to show one picture, a quote or a chess game during long Claude tasks.

    View prompt
    Using the HeyCubit/effortless repo, install the textless desktop app from its Install link and choose a pixel-art set. Start a Claude Code task and report whether a single picture replaces the step output while Claude works.

  • Review a branch for new PHP debt before merge

    Compare a branch with main and rank only the findings it introduced, highest risk first.

    View prompt
    In the Heyosseus/sloppy project, run the diff and review commands against main for the branch checked out in <project path>. Output the top five ranked findings with their file and rule identifier. Verify that every finding is in a file the branch changed.

  • Let the AI use your other services via MCP

    Connect a remote MCP server so the AI can call its tools while it builds your project.

    View prompt
    Using the HeyPuter/builder live demo at https://builder.puter.com/, connect the remote MCP server at <target server URL> and ask the AI to use one of its tools to update <target project>. Expected output: a project change that uses the tool's result. Verify that the tool call result appears in the live preview and that the connection was made to the URL you provided.

  • Delegate independent tasks to other agents through a Worker plan

    Hand separate, independent tasks to other agents while Hi Route tracks their execution and cost.

    View prompt
    Using the HiRoute repo at https://github.com/higress-group/HiRoute, expose a Worker plan that delegates <list of independent tasks> to other agents. Report the status and model group of each delegated task. Verify that each delegated execution appears in the local session view with its usage and cost.

  • Turn research material into a report or slide deck

    Generate a PPTX, PDF, spreadsheet or Markdown deliverable from uploaded source files.

    View prompt
    Using the repo himovo/movo, run ./movo up, then upload <source files> and ask the content generation feature to create a <format> deliverable on <topic>. Return the file path and check that the file opens and includes content from each source.

  • Add a new country generator to the Yowes codebase

    Extend Yowes with a country package that subclasses the base generator and registers itself.

    View prompt
    In the hirotomasato/yowes repo, add a country package for <country name> by subclassing countries.base.CountryGenerator and registering it in countries/__init__.py. Expected output: a working package and a registered country code. Verify that list_countries_tool returns the new code after the server restarts.

  • Let the agent repair a failing generated script

    When generated bpy code errors, the add-on sends the log back so the agent corrects the script.

    View prompt
    In hitkeeen/blender-ai-addon, send a prompt that is expected to need repair and confirm the Auto-fix loop returns a corrected python block. Expected output: a corrected script that runs without error in the Blender scene. Verify the final run in the add-on reports success and check server.log if the server failed to start.

  • Run coding agents against local models

    Point the gateway at Ollama, LM Studio, or llama.cpp so requests stay on your machine.

    View prompt
    In the my-free-code repository, set OLLAMA_BASE_URL and MODEL=ollama/<model-name> in .env, start the gateway with python -m my_free_code, and send one test request. Expected output: a completed response generated by the local model. Verify that no hosted provider key is required for the request to succeed.

  • Search and convert a Calibre ebook library with an agent

    Have an agent search, read metadata from, and convert books in a Calibre library through its CLI.

    View prompt
    Using the HKUDS/CLI-Anything Calibre CLI, search the library at <library-path> for <search-term>, then convert one matching book to <format>. Report the matched titles and the output file path. Verify that the converted file opens or has a non-zero size.

  • Remake a launch video frame by frame for your brand

    Rebuild a reference launch video shot by shot in your own brand, with a side-by-side compare against the original.

    View prompt
    Using the remake mode in the claude-motion-design skill, make a frame-locked remake of <reference video> for <brand name> with the brief in <brief file>. Expected output: a shot-by-shot spec, a rendered remake and a split-screen MP4 labelled original and new copy. Verify that no music, voice or people photos from the reference appear in the output.

  • Continue an earlier agent conversation in a writable room

    Import a Codex or Claude Code history and continue it in a normal room without changing the source.

    View prompt
    In the PeerBridge MCP control room, import only the Codex conversation <conversation-id> from the agent history list and use Continue from history to create a writable room. Report the new room ID, and verify that the source room remains read-only.

  • Run MobileCode from source to change it

    Clone the repo, install with Bun, and run the backend, web UI, or desktop app.

    View prompt
    Clone https://github.com/hsandhu/mobilecode into a local folder, run bun install, then start the backend with `bun run --cwd packages/opencode src/index.ts serve --port 4096`. Expected output: the backend running on port 4096. Verify by confirming the server responds locally before reporting that the source build works.

  • Try the terminal interface without installing

    Run the latest hmz release from uv's cache to test the terminal interface first.

    View prompt
    Using the humanize repo (hmz), run `uvx hmz@latest` inside <scratch-repo-path>. Report the first screen or prompt the interface shows, as plain text. Verify that the interface opened from the scratch repository and did not change any files in <scratch-repo-path>.

  • Check whether a site connection is still signed in

    Run a health check without AI that separates signed-out, changed, blocked, and unreachable sites.

    View prompt
    Using the Hycli repo, run `hycli check <site-name>` and report the status it returns: signed_out, site_changed, blocked, or unreachable. Expected output: one status and no LLM call. Verify the status before reconnecting an account or re-preparing the site.

  • Build a GameCube or Wii game from its own C source

    Drive files toward linked status so the game rebuilds from C and matches its checksum.

    View prompt
    Using the decomp.wtf repo (i12bp8/decomp.wtf), import the GameCube or Wii image at <path-to-game-image> that I own and work toward linked files. Report the count of linked files and the % linked figure. Verify that a file is only kept as linked when the full game still passes its checksum.

  • Run a web research goal with evolved browsing agents

    Let an evolved population search the web through local SearXNG and rank answers by a locked benchmark.

    View prompt
    In the KADATH repository, start the runtime with ./kadath.sh and create a run for the research goal <goal> with web search enabled. Report the top agent's fitness and list the public sources it cites, and verify that each cited source appears in its frozen evidence.

  • Play a scroll animation or ad video in the chat

    Have Claude Code record a video of its work and review it in a player with timestamps inside the terminal.

    View prompt
    With the claude-show-your-work plugin in Claude Code, record a video of <target page or animation> as it scrolls from top to bottom and play it in the chat. Expected output: a playable video in the chat with timestamped steps in the sidebar. Verify that the timestamps jump to the matching moment in the video.

  • Watch figure objects draw live in Mac PowerPoint

    Set up the optional Office.js add-in so each object appears in Mac PowerPoint as it is drawn.

    View prompt
    In the scientific-illustrator repo on macOS, run the officejs-setup.mjs prepare and sideload steps, then confirm that powerpoint_officejs_status reports connected=true with the Scientific Illustrator Live task pane open. Verify the connection before asking the plugin to draw the uploaded figure in PowerPoint.

  • Locate failed and slow tool calls in past Codex runs

    Search and filter earlier task history to find failing or slow tool calls and inspect them.

    View prompt
    Using the icesixgod/codex-trajectory repo, search the history of the Codex task <sessionId> for failed or slow tool calls and list the matching events with their durations and status. Verify that each listed event has a status and that zero and sub-millisecond durations are not reported as failures.

  • Add API contract tests with Zod validation and fixtures

    Write API tests using the apiRequest fixture, Zod schema checks, and setup and teardown helper fixtures.

    View prompt
    In the agentic-playwright repo, write an API test for <api-endpoint> using the apiRequest fixture and a Zod schema, with setup and teardown fixtures. Expected output: a passing API spec that validates the response shape. Verify that the schema is defined with Zod and that `npm test` passes.

  • Import the five ARS skills into Claude Science

    Load the research, writing, review and pipeline skills into Claude Science from the GitHub repo.

    View prompt
    Import the skills from https://github.com/Imbad0202/academic-research-skills into Claude Science, then confirm that all five ARS skills are listed. Expected output: five imported skills. Verify that the imported version is v3.14.0 or later before relying on it.

  • Generate text for a prompt list offline in Python

    Run many prompts through a supported checkpoint in one Python script without starting a server.

    View prompt
    In the vllm-rlt repository, write and run a Python script that loads ByteDance/Ouro-1.4B through the Python API and generates text for every prompt in <input file>, writing results to <output file>. Expected output is one line per prompt. Verify that the output has the same number of lines as the input.

  • Split a track into stems and remix them in the DAW

    Separate any saved track into vocals, drums, bass and other, then rearrange and export them in the timeline editor.

    View prompt
    Using the repo inikolax/remiqora, separate the saved track <track name> into stems and open them in the editor. Expected output: a four-track project with vocals, drums, bass and other, exported as a mix or as stems. Verify that the exported file plays back with all four parts audible.

  • Reopen a saved tour without waiting for the LLM again

    Return to a change you toured earlier and open its saved tour instantly.

    View prompt
    In the repository at <path>, open the saved tour for the branch <branch> with tour. Expected output: the tour opens without the writing step. Verify with `git status` that the repository is unchanged.

  • Check what early access does today before signing up

    Create an account and redeem a code to see the current state: credits are reserved, and generation is not live.

    View prompt
    Visit inkloom.art, read the early access and generation status text, and report whether logo generation is available and how credits are described. Verify by quoting the exact status and credit wording found on the site.

  • Add a custom media provider to the pipeline

    Wire your own REST image, audio or 3D provider into Noobi AI through its provider store and service.

    View prompt
    In the Noobi.ai repo at <path>, add a REST provider adapter for <provider name> by following src/main/mediaProviderStore.ts and src/main/mediaGenerationService.ts. Expect a passing typecheck and test run; verify that the new route is configurable and that generated assets still pass the existing validation before proposing a pull request.

  • Open a local dev server running on your Mac from your iPhone

    Use the Preview Chip to open a dev server an agent started, through the Lody Quick Tunnel.

    View prompt
    Using the Innei/lody-ios repo README, explain how the Preview Chip opens a local dev server reported by an agent on the user's Mac. Output the steps in order and note what the Quick Tunnel carries. Verify that the output says only short-lived tunnel links reach the app.

  • Turn a site's scroll animations into a runnable GSAP stub

    Census a live page's scroll motion and generate a single-file GSAP ScrollTrigger starting point.

    View prompt
    Use the awwwards-mcp server to run analyze_scroll_map on <target URL>, then pass the result to build_gsap_stub. Expected output: a runnable single-file GSAP plus ScrollTrigger stub with one timeline per census animation and a prefers-reduced-motion guard. Verify the stub opens without errors and that the timeline count matches the census.

  • Make a summary page accessible for ADHD or dyslexia readers

    Add the accessible mode to a summary page so readers get the same facts with less visual load.

    View prompt
    Using the summary skill in accessible mode from isas1/skills, build an HTML page for the repo at <path>. Expect one self-contained page with the same facts as the plain version. Verify that the page contains no motion and that its facts match a plain summary.

  • Let an agent act only when it is confident

    Use Jev confidence scores to proceed on clear cases and escalate unsure ones.

    View prompt
    Use the evaluate tool from the itsmostafa/system-one-connector repo to answer this question about <case description>: <your question>. Proceed only if the top probability is at least <threshold>, otherwise return 'escalate'. Verify the returned confidence field matches the highest probability before deciding.

  • Speed up repeat evals with a prebuilt prompt cache

    Point llama-server at a read-only prompt cache folder so long eval prompts skip re-reading.

    View prompt
    In the llamAmpere repo at <repo path>, start llama-server with the Swift 1.5 model and `--eval-cache <cache directory>`. Run the eval prompts in <eval file> twice at temperature 0 and report the time of each run and whether the two outputs match. Verify that the second run is faster and that the outputs are identical.

  • Price a 100-agent run before you spend tokens

    Print the rounds, calls and waves for any agent count before the tournament starts.

    View prompt
    Using the repo at https://github.com/Jakeschincariol/arena-skill, run python3 skills/arena/bracket.py plan --agents <N> and report the rounds, sub-agent calls and waves. Expected output: the bracket table that the command prints. Verify that the command writes no files before you start a real run.

  • Find an acceptable price range from buyer answers

    Turn four price answers per buyer into a range and check your planned price against it.

    View prompt
    Using the Jakeschincariol/founder-skill repo, run `python3 skills/founder-pricing/van_westendorp.py founder/panel/answers --price <planned price>` and report the acceptable price range, the optimal and indifference prices and whether the planned price falls inside the range. Verify that the input is either panel answers or a real survey CSV and say which one was used.

  • Score your LinkedIn profile and fix the weakest parts first

    Get a 100-point profile score and a rewrite ordered by what loses the most points.

    View prompt
    Using the li-profile skill from https://github.com/Jakeschincariol/linkedin-agent-skill, score the profile text I paste from <path or paste of profile> and return the total out of 100 plus rewrites in fix-first order. Verify that no metric, client or outcome appears unless I supplied it.

  • Control the robot over USB serial instead of Wi-Fi

    Connect the robot by USB cable and drive it from your agent through the serial transport.

    View prompt
    Use the repo github.com/jamro/tiny-engineer and its serial transport described in docs/serial.md. Run `npx -y tiny-engineer --transport serial` on the machine connected to the robot at <serial port>, then report whether the robot responds. Expected output: a confirmed serial connection and a pose change on the robot. Verify the robot reacts to one test pose.

  • Pull a 3D model apart by hand

    Drop a 3D model into the media folder and scrub its exploded view with your fingers.

    View prompt
    In the barehands repo, copy <model file> into media/models/ and confirm it appears in the Props orb after the server starts. Expected output is a list showing the model file in that folder. Verify that the file is inside media/ because only files there appear on the board.

  • Self-host the Intermission game server

    Use deploy.sh to build and run the stock Odamex server on your own droplet.

    View prompt
    Clone jarrodwatts/intermission, read deploy.sh, and summarize every command it runs before anything executes. Then run it on the <droplet-host> target only after I approve, and report whether the Odamex server process is running.

  • Measure your AI coding usage across tools and projects

    Count sessions, projects, and models over time from your extracted assistant conversations.

    View prompt
    Using the repo jatechan/ai-data-extractor, read extracted_data/all_conversations.jsonl from <project folder> and count unique session_id values grouped by source and by month of the timestamp. Output a CSV table with those counts. Verify that the total of session counts equals the number of unique session_id values in the file.

  • Approve or deny each agent tool call visually

    Review every tool request in a dock and allow or block it before it runs.

    View prompt
    Using the repo Jaxton07/percho, start a session in <project-folder> and send a prompt that triggers one tool call. Report the tool name and the approval decision you made, and verify that the tool did not run before approval.

  • Audit token spend by agent, model and session

    Review 30 days of token history and estimated API cost per agent, model, session and turn.

    View prompt
    In the agent-hud-open repository, run `make run`, then open the statistics window and report the token total for the last 24 hours for each agent shown. Verify that the cost figures marked ≈ are labelled as estimates.

  • Let Claude Code browse the catalog and run read-only SQL

    Connect Claude Code to the OLCF MCP endpoint to explore tables, follow lineage and query safely.

    View prompt
    Use the open-lakehouse-compute-fabric repo (jddevtime/open-lakehouse-compute-fabric) through its MCP endpoint. List the catalog assets in the sample Retail lakehouse, then run one read-only SQL count on <table name> and return the result. Verify that the query was rejected if you ask for any write statement.

  • Track how often AI engines cite your site each week

    Run a fixed question set weekly and compare cited rates and share of voice.

    View prompt
    Using the geo-score repo at jianruntech/geo-score, run `geo_score.py watch run` against the question set for <target-domain> using my own API keys. Expected output: a weekly report with cited rate, its 95% interval and share of voice. Verify that the diff between this week and last week is labelled as a real change only when the paired test supports it.

  • Make a verified task harder and measure its difficulty

    Derive a harder child task from a verified one, then measure it with fresh solver attempts.

    View prompt
    Using the EvoTrace repo at https://github.com/jinzijian/EvoTrace, run /harden 1 and then /calibrate on the resulting child asset in the DeepSeek Harness app. Report the calibration pass count out of attempts and the added behavior. Verify that the child task adds testable behavior, compatibility, edge cases, or failure constraints rather than only a longer patch.

  • Answer ten pre-code questions before writing a feature

    Have the agent answer ten questions against the real code before it writes a feature.

    View prompt
    In the <repo-name> repo, run premortem on this feature: <feature-request>. Expected output: ten answers covering running twice, stopping halfway, outside service failure, neighbors, endings, money, hostile users, words, scale and time, each as file:line, a test, or Not handled. Verify that each file:line points to code that exists.

  • Run public runtime tests before changing the runtime

    Run the dependency-free public runtime test suite to confirm a clean baseline before editing the local runtime.

    View prompt
    In the pixelcrabs repository root, run the five public runtime test files with `node --test` as listed in the README. Expected output: a pass or fail summary for each test file. Verify that no test requires installed packages before reporting a baseline.

  • Learn an OpenStreetMap bake pipeline and pseudo-3D renderer

    Read a commented renderer and map bake pipeline to learn how a real road becomes pixel art.

    View prompt
    In the jonwheatley/pixel-path repo, bake a short placeholders route with the pixel-path skill and explain how the bake pipeline and the pseudo-3D renderer connect. Expected output: a written explanation with file references. Verify that each file named in the explanation exists in the repo.

  • Feed facts into memory from scripts and cron

    Use the headless lemmalog-cli to observe facts and run queries from shell scripts or scheduled jobs.

    View prompt
    Using lemmalog-cli with snapshot <snapshot path>, observe the facts in <input file> and then run a query for <entity>. Expected output: the observe report with any dropped lines and the query results. Verify that no line was silently dropped.

  • Build and update the robot firmware from source

    Compile the CoreS3 firmware yourself and push updates over Wi-Fi with on-device OTA.

    View prompt
    In the groki-bot repo, follow docs/build.md to build the CoreS3 firmware from source and list the output artifacts. Verify that the build finishes without errors before any flash step.

  • Build Opensidian from source with a pinned Rust toolchain

    Compile the release binary from the repo using the Rust version the README tested.

    View prompt
    Clone jpzk/opensidian into <work-folder>, go to src-tauri, and run cargo build --release --locked using Rust 1.98.0. Report the final cargo line and the path of the built binary. Verify that target/release/opensidian exists and is executable before reporting success.

  • Benchmark your model on CoLA against GPT-1

    Run the included CoLA benchmark on your trained model and compare the score to GPT-1's 45.4.

    View prompt
    In the jrz97619761/test-model-thing repo, with trained weights present, run `python benchmark.py` and report the CoLA score. Verify that the score is reported next to the README's GPT-1 figure of 45.4.

  • Keep background music on brand with a saved kit

    Save BPM, mood, and no-vocals settings once and reuse them for every recommendation.

    View prompt
    Using the sonicmatch MCP server from js713-lab/sonic-match-mcp, save a brand kit named <kit name> with the BPM range, moods, and no-vocals setting from <brand guide>, then run recommend_bgm with that brand_kit on <path to clip.mp4>. Return the ranked tracks with licenses. Verify that every track came from the user library or a license you accept for this use.

  • Enforce thresholds on Ragas or DeepEval scores

    Import selected Ragas or DeepEval metrics and apply a policy gate to them.

    View prompt
    Using https://github.com/jsdhwfmax/EvalForge, import a Ragas export at <ragas-records-path> with `evalforge import ragas` using explicit --metric flags, then run `evalforge gate` on the output with examples/ragas_policy.json. Expected result is a gate verdict built only from the selected score columns; verify that no sample text appears in the output artifact.

  • Run the ASM workflow from the Codex project package

    Open the Codex project version and ask the agent to run an ASM modeling task.

    View prompt
    Open the autowwtp-asm-codex project at <repo-folder>/code/autowwtp-asm-codex in Codex and read AGENTS.md. Run the ASM modeling task described in <task-file> on the data in <input-file>. Expected output: a report and a final_result.json. Verify that the process checks file exists before reporting success.

  • Turn a long novel into a series episode outline

    Convert a long manuscript into a numbered episode outline with a series engine and bible, using the Chinese series skill.

    View prompt
    Using the screenwriting-skills repo (sw-chinese-series-practice and sw-series-engine-bible), read <novel synopsis or file> and produce a series engine statement plus a numbered episode outline for <target episode count> episodes. Verify that each episode has a distinct turn and that the engine statement is stated before the episode list.

  • Correct an oncology record and open a pull request

    Edit a record in the corpus, run the checks and submit a change that passes the same safety gate.

    View prompt
    In a local clone of judegomila/OnCo, update the record with id <record id> in src/data/ so that it matches the primary source <source URL>, set asOf to today's date, and run `npm run validate`. Expected output is a clean validation report and a diff limited to that record. Verify that the new link resolves and that no other record changed.

  • Compare your site against a competitor's

    Score two sites side by side with the same rubric and evidence.

    View prompt
    Using the juliobsz/skills repo, run /jury on <your URL> vs <competitor URL>. Expect two scorecards in the .jury/ folder with the same categories. Verify that both sites were scored with the same rubric and that each score cites its screenshots.

  • Have a Claw agent review a repository with approval gates

    Run a sandboxed agent that reads a repo and runs code, with you approving every write.

    View prompt
    Use the Claw agent in Xyne Spaces to review the repository <repo-name> that is connected to my account. Expected output: a short review listing issues by file and line. Verify that every write action waits for approval and that no write happens without a card being approved.

  • Get a Slack or email alert when a live agent run fails

    Build an alert flow that notifies you when a judge fails a live conversation.

    View prompt
    In the Tracely-ai repository, start the stack with `docker compose --profile demo up -d --build --wait` and create an alert rule at http://localhost:3001 that fires when an evaluator fails a live conversation and sends a Slack message. Report the rule name and the output of a test run. Verify that the test run shows the payload each step sent.

  • Check a private Markdown folder before startup

    Preflight your knowledge directory and get a safe document count and relative file list.

    View prompt
    In the jzjzzzzzzz/agent-me repository, run the knowledge check against the <knowledge-dir> folder using the JSON option. Return the document count and relative paths only. Verify that the output contains no document text and no absolute host paths.

  • Export a favicon, app icon and web manifest set

    Generate a complete favicon, app-icon and web-manifest set from a finished SVG logo.

    View prompt
    Using the export tools in kaankiziltug/logo-design-skill, generate a favicon, app-icon and web-manifest set from <path to logo.svg> into <output folder>. Return the file list. Verify that each expected icon file is present and that the manifest references them.

  • Check a part for overhangs and thin walls

    Run the analysis tools on a model to find overhangs, thin walls and weak spots before printing.

    View prompt
    In the SOMA model folder for <model name>, run `soma analyze` on the model and list every overhang and wall thinner than <minimum wall thickness> millimeters. Propose code changes for each issue, then run `soma build` and confirm the build still succeeds.

  • Choose benchmarks to test a robot-use agent

    Pick simulation benchmarks from the list that match your robot and task before you run tests.

    View prompt
    Read the Benchmarks section of https://github.com/kairunwen/Awesome-Robot-Use-Agent and recommend two or three benchmarks for testing a robot-use agent that must <task>. Output the benchmark names, the task type each covers, and the README link for each. Verify each benchmark name appears in the README before you recommend it.

  • Export one edit to nine social platforms at once

    A single render command makes a file for each platform template and a summary table.

    View prompt
    Using the ffmpeg-skill repo, render <source video> with --template all so it covers every platform template. Expected output: one file per platform plus a _pack.md summary table. Verify the summary lists every destination and that each output probes correctly.

  • Extend or restyle an existing track with edit_audio

    Lengthen a generated track, change its style, or regenerate one section.

    View prompt
    Using the audio-studio MCP server from the audio-studio-mcp repo, call edit_audio with continue on <path to track> to extend it to 90 seconds, with 2 candidates. Then call process_audio to normalize the chosen file to -16 LUFS. Verify that the output is about 90 seconds long and that its .json sidecar keeps the source generation info.

  • Watch context, cost and subagents in a live dashboard

    Use flightdeck to see context use, cost, permission checks and subagents while Claude works.

    View prompt
    Using the karanb192/awesome-claude-code-mods repo, find the flightdeck mod and summarize what it shows and what access it reports. Expected output: a list of dashboard items (context, cost, permission checks, subagents) and the access details. Verify that the README states it does not change tool calls before recommending it.

  • Keep every session warm with always mode

    Turn on always mode so each turn leaves at least six hours of warm window across sessions.

    View prompt
    In the karanb192/cache-tax repo, with the plugin installed, run /keepwarm always in a Claude Code session and then /keepwarm status. Report the warming window and next ping. Verify that the window reaches at least six hours after the last turn.

  • Recheck an old FY 2025-26 tax result after the 1.3.0 fix

    Recompute your FY 2025-26 tax to see whether an earlier install understated new-regime tax.

    View prompt
    Using the itr-wala repo at <repo-path>, update to version 1.3.0 or later, then recompute the FY 2025-26 tax for <your-income-file>. Expected output: a recomputed new-regime total and the difference from the earlier result; verify the engine version is 1.3.0 or later before comparing with the filed return.

  • Pin an approved redesign with a seed and report

    Reproduce an approved direction exactly and keep a decision report beside the artifact.

    View prompt
    In a clone of the reimagine-it repo, run `npm run auto -- -i <path-to-page.html> -o review/auto.html --report review/auto.json --seed 42`. Expected output: review/auto.html and review/auto.json. Verify that the report lists the selected direction and source-fidelity checks, and that a second run with the same seed produces the same page.

  • Map how a feature works across an unfamiliar repo

    Use agy's researcher persona to survey a topic in a codebase you do not know yet.

    View prompt
    Using the keli-wen/agy-staff plugin, ask the researcher persona how <topic> works in <repo>. Expect a written report on that topic. Verify that the report cites specific files or functions it read.

  • Preview a web UI and send visual feedback to the agent

    Check your project's live previews across screen sizes, select a page element, and send feedback to the agent.

    View prompt
    In BetterC0de Canvas mode, open the live preview of <project-path> and select the element at <element-description>. Send feedback describing the layout problem to the connected agent and report the file the agent changed. Verify the change by reloading the preview at two screen sizes.

  • Screen web search results for hidden instructions

    Withhold parts of web results that carry instructions aimed at the agent.

    View prompt
    On this Hermes machine, enable `/jev screen shadow` for the <profile> profile using the hermes-jev-skills repo from kerpopule. Run a web_search and a web_extract, then report which chunks would have been withheld and why. Confirm that the local pattern screen still runs if Jev is unreachable.

  • Queue design cards for the built-in Doop Agent

    Turn on the built-in agent with an Anthropic key and let it pick up cards without a client.

    View prompt
    In the repo kgoedecke/doop, with ANTHROPIC_API_KEY set in .env, start the dev server with `bun run dev`. Queue one board card on canvas <canvas-id> asking for a hero section, then check the Agents panel and report whether the task was claimed and which frame it produced.

  • Teach the factory-to-shop flow using the live view

    Use the running town to show how goods move from Factory to warehouse to shop.

    View prompt
    Using the repo Khalidabdi1/factory running locally with `npm run dev`, list the cards you can open for Plant 01, Warehouse 01 and Corner Market. Verify each card shows live details before you write the teaching notes.

  • Check another agent's "done" claims before accepting them

    Verify each claim from another session against what actually happened, then get a next action.

    View prompt
    In the open-steps repo at <repo-path>, use the os-check-work skill to verify the claims in the report from <other-session> about pull request <number>. Expected output: each claim marked against what actually happened, followed by one recommended action. Verify that no claim is accepted without a check.

  • Plan a long multi-batch corpus task with a Task Plan

    Publish a confirmed Task Plan and compile a resumable Queue for large corpus work.

    View prompt
    In the Cambium repo at <repo-path>, help me complete a Task Plan at .cambium/deltas/task-plans/TP-001.yaml for the corpus at <target-path>, then run the dry-run init_state.py command. Report the printed compile_queue command and the check_queue result, and do not apply anything without my confirmation.

  • Shortcut a repeated status check for your team

    Save a status-check request as a project slash command that reports and never writes.

    View prompt
    In the project at <project_path>, use the faq-shortcuts skill from cli-faq-shortcuts to create a shortcut for my repeated status check. Expected output: a SKILL.md under .claude/skills/ that names the existing script or query it uses and reports without re-sending. Verify that the shortcut runs its query and reports the result.

  • Generate 16:9 and 9:16 thumbnail batches from a table

    Fill a table of campaign messages and let AI fields create linked thumbnail variants for each record.

    View prompt
    In the Kition desktop app, open the table <table name> with campaign messages and AI thumbnail fields. Ask the Agent to list each record whose 16:9 or 9:16 variant is missing, and confirm the list before regenerating anything.

  • Queue a capture into an OpenCode session

    Send a finished bundle straight into an OpenCode session using the Scrawl send command.

    View prompt
    Run `scrawl send <bundle-path> --session <session-id>` for the capture at <bundle-path>, then confirm the OpenCode session received the contact sheet and summary.md. Report the session ID you sent to.

  • Stop tool use when a session shows a mismatch

    Turn on halt_on_mismatch so Codex blocks tools until you say resume after a mismatch.

    View prompt
    In the kiyoakii/is-gpt-nerfed repo, set halt_on_mismatch to true, then confirm the setting is saved with `nerfed config` output or the app Settings. Report the current value and whether a mismatch has blocked tools in any session.

  • Run the synthetic incident evaluation against one API

    Measure predictions and latency on versioned synthetic incident inputs.

    View prompt
    In the kkjiangk/agent-py repository, follow evaluations/README.md to run the synthetic incident evaluation against the API at <api address>. Report the predictions and latency for each scenario. Verify that the output lists every scenario in the versioned dataset.

  • Run one routine across a shelf of phones, each with its own proxy

    Drive many phones from one PC, each sending chosen apps through its own upstream.

    View prompt
    Using the Droidline repo at https://github.com/KnifeLemon/Droidline, write a script that runs the same routine on each paired phone in <phone list>, with each phone using its own proxy upstream. Output one JSON line per phone with its name and a pass or fail result. Verify every phone reports a route in its status before it runs the routine.

  • Save a chat session and resume it later

    Export a conversation to a file and import it to continue where you stopped.

    View prompt
    Using the Chat_UI repository at KODAMA-TECHNOLOGY/Chat_UI, export the chat history from the page to <history-file>, close the page, then reopen it and import <history-file>. Report that the earlier messages are visible again and verify that the message count matches before export.

  • Build an accessible FAQ section in an existing app

    Add an FAQ section where answers stay readable to assistive technology.

    View prompt
    Use the component-builder skill from kostja94/bricks to build an FAQ Section for <target page> in <target project>. Reuse the project's existing primitives and choose a variant from the real questions. Verify that every answer is reachable by keyboard and assistive technology, and list the files changed.

  • Add Jev decisions to a JavaScript or TypeScript app

    Call the Jev API from Node.js with typed Choice, Noul, and Score questions.

    View prompt
    Using the repo kraayenjon/awesome-jev and the @typesafe-ai/sdk npm package, add a function in <target file> that takes a request body, sends it to client.systemOne with a choice question and a noul question, and returns both answers. Verify that the function compiles with TypeScript and that the returned object contains an answer for each question name.

  • Recover a Mac after a session that could not be undone

    Find and clear the recovery warning, unfreeze processes and restore audio after a crash or quit.

    View prompt
    In the repo https://github.com/krishhgg/Insomnia, read docs/recovery.md and the log at ~/Library/Logs/Insomnia/insomnia.log on this Mac. Report each recovery warning and the step from docs/recovery.md that addresses it. Verify that you did not change any power setting while reporting.

  • Restore a single still image from the command line

    Restore one image file with a single command and save the result as a new file.

    View prompt
    Using the Jasna repo at Kruk2/jasna, run `jasna --input <image path> --output <output image path>`. Expected output: a restored image at <output image path>. Verify that the file opens and that the mosaic area looks different from the original while the rest of the picture is unchanged.

  • Delegate a Triton-Ascend task to a matching skill

    Pick one of the 24 bundled skills for a specific kernel job and run it through the agent.

    View prompt
    In the triton-ascend-agent-dev-kit workspace, list the skills/ folder, choose the skill that best fits <task-description>, and apply it to <target-kernel>. Expected output: the skill name you chose, the changes made, and a one-line reason for the choice. Verify the changes against the matching guide in triton-ascend-dev-doc/.

  • Show each workspace's active task in the Herdr sidebar

    Display the active tab's topic under each workspace name in the Herdr sidebar.

    View prompt
    For the repo kryptamine/herdr-auto-title, add the README's [ui.sidebar.spaces] rows containing the $topic token to the Herdr config.toml on <target machine>, then restart the plugin. Report the sidebar rows for two workspaces and confirm each shows a topic line under its name and branch.

  • Turn a one-hour meeting into a page of minutes

    Andee holds the mic during a meeting, then returns decisions, action items, open questions and key quotes.

    View prompt
    Using the Andee repo at github.com/kuafuai/andee on an Android phone, record a meeting and produce minutes. Expected output: a page with sections for decisions, action items, open questions and key quotes. Verify that the audio and transcript are sent only to the speech provider and model you selected.

  • Get hint-only /compact advice in Codex CLI on macOS or Linux

    Install the Compact Adviser hook in Codex CLI to see a compact hint after each finished turn.

    View prompt
    Install compact-adviser in Codex CLI on <target macOS or Linux machine>: add the kunchenguid/compact-adviser marketplace, add compact-adviser@compact-adviser, then restart and trust the hook in /hooks. Expected output: a Compact adviser hint line appears after a completed turn. Verify the hook is trusted before reporting success.

  • Retest a fixed vulnerability and record whether it still reproduces

    Start a retest on one finding and get a result of still reproducible, fixed, or cannot confirm.

    View prompt
    Using the repo kutukam/autonomous-pentest-agent, start a retest for finding <finding-id> in task <task-id> with the fixed version <version>. Report the verdict and the session link. Verify that the verdict and the evidence are saved in the finding details before you close the task.

  • Test soft-target training with RLCDLoss on your own labels

    Use probability distributions as targets and run one loss and backward step to study the calibration-oriented objective.

    View prompt
    In the repo https://github.com/kyegomez/open-jev, build soft probability targets for <your question set> and compute RLCDLoss on the model with one backward pass. Expected output is a scalar loss tensor with gradients; verify that each target row sums to 1 before calling the loss.

  • Review PET/CT fusion and align it manually

    Fuse PET and CT in slices and 3D, adjust the blend, and register the two volumes by hand.

    View prompt
    Work in the repo l5769389/voxenra. Run `uv run voxenra`, import the PET and CT series at <path to PET/CT study>, and open the fusion view. Report whether the PET overlay aligns with CT anatomy at the slice you chose, and state the blend ratio used.

  • Write a custom rule for your own code standard

    Add a plain-English rule to Perch.yaml so Perch checks a practice your team cares about.

    View prompt
    In the perch repo at <project path>, add a rule named private-logs to perch.yaml with where set to src/**/*.ts, each set to method, and ensure set to 'Keep passwords and access tokens out of logs.' Run `perch scan`. Verify that the scan output includes findings from this rule.

  • Run a Codex agent next to your Claude Code agents

    Switch one character from Claude Code to Codex and follow its terminal on the Mac.

    View prompt
    In the chums repo at <target-folder>, run bin/chums-codex and confirm a Codex terminal opens on the same conversation as the watch agent. Expected output: a Codex session you can follow on the Mac. Verify with bin/chums-doctor that the Codex path reports no failures.

  • Generate a sung track from your own lyrics offline

    Write a style and lyrics with section markers, then generate a song with ACE-Step 1.5 in the local studio.

    View prompt
    Using the leemysw/yovoice repo, write a Music project with the style <style description> and the lyrics in <lyrics file>, using ACE-Step 1.5. Expected output is a generated song with synced lyrics; verify that all section markers from the lyrics file appear in the playback view.

  • Check a Minke installer against published SHA-256 digests

    Confirm a downloaded Minke package matches the official release checksums before installing it.

    View prompt
    Using the lencx/Minke README and its SHA256SUMS release file, verify the SHA-256 digest of the downloaded <package-file>. Expected output: a match or mismatch report for that exact filename. Verify that the filename in SHA256SUMS matches the downloaded package name before comparing digests.

  • Build a seamless 10-second muted loop for a landing page

    Render a looping feature animation that autoplays without sound on your site.

    View prompt
    Using the cinetic skill in Leonxlnx/cinetic, make a 10-second 1920x1080 feature loop with no sound that shows <feature name> from <product name>. The loop must join seamlessly at the end frame. Verify the first and last frames match before you report the file path.

  • Block Claude Code from ending a session with unmet gates

    Install an optional Stop hook that holds the session open while gates remain unmet.

    View prompt
    Use the unlazy skill in the repo <repo-path> to keep this Claude Code session on <task-name> until its gates pass. Run node /scripts/install-hooks.mjs, then run the session and report whether the Stop hook blocked exit while gates were unmet. Verify that .claude/settings.local.json is listed in the project's ignore rules.

  • Capture a screenshot or PDF of a web page

    Save a PNG or PDF of a rendered page for review, reports, or visual checks.

    View prompt
    Using the repo lexmount/moli, run `moli fetch --layout --dump screenshot <target-url> > page.png`. Save the PNG and report its file size. Verify that the file opens as an image showing the page.

  • Run Jev Mem memory decisions on a local Laya model

    Swap the System-One backend to Laya so memory decisions run locally without a TypeSafe API key.

    View prompt
    In the Jev-Mem repository at <target-folder>, install the '.[laya]' extra and run the LoCoMo benchmark on examples/locomo_synthetic.json with config/laya_mem.json, using --max-questions 2. Report the output and confirm that no TypeSafe API key was set.

  • Split a large Blender task across an agent team

    Use a Team chain with a manager, workers and reviewers to run a structured multi-step scene task in order.

    View prompt
    Using the mcp-for-blender-pro repo, configure a Team chain with one manager, one worker and one reviewer, then give it the task <scene task description>. Return the task board summary with each assignment and its review result, and verify that the reviewer approved the final state of the scene.

  • Count matches in a huge tree without flooding output

    Get a match count and file count from a very large tree in one short result.

    View prompt
    Use the aside-codemode execute_code tool to run search.count for <pattern> under <root folder> and return the matching line count and file count. Verify the totals against a small known subfolder before trusting the full-tree figure.

  • Find which sites AI engines cite for your category

    See which pages engines trust, classified as your own, competitor, social, informational or other.

    View prompt
    Using limelit-co/open, run one pass for the brand <target-brand> in the category <category>. Export the citation data and list the top 10 cited sites with their source type. Verify that each classification matches the stored citation rows.

  • Give a local AI agent read-only access to your records

    Install the headless tools and connect an MCP client so it can query your local Zepp Bridge database.

    View prompt
    Using the zeppbridge-mcp server configured in <path to MCP config>, list my workouts for <date range> and report total distance and training load. Expected output: a table of workouts with dates. Verify that the server only reads the local database and that no workouts outside the range are returned.

  • Find skills gaining installs and social attention

    Compare the 7-day trending list with the social buzz list to see which skills are rising and talked about.

    View prompt
    Using the LinklyAI/best-skills repo, compare rankings/trending-7d.csv and rankings/social-buzz.csv from the newest dated folder under data/. List skills that appear in both files, with their Weekly Δ% and their X, HN, Bluesky and GitHub counts. Verify each skill name appears exactly as written in both CSVs.

  • Compare speculative and target-only generation

    Run the same model with DSpark drafting on and off to see how the setting changes output speed.

    View prompt
    Using the lithos-metal repo at https://github.com/lithos-ai/lithos-metal, run the same fixed prompt against `lithos-metal serve --model nvidia/Qwen3.8-27B-NVFP4` and again with `--no-draft`. Report wall-clock time and generated token count for each run in a two-row table. Verify both runs used the same prompt and max_completion_tokens before comparing.

  • List your DSH plugin in the community catalog

    Add the right keyword and metadata to your npm package so the daily build discovers and lists it.

    View prompt
    Check the package.json of the plugin at <plugin-path> for the dsh-plugin keyword, a dsh.bundle field, a license, and a source repository, as listed in the LivXue/dsh-plugin-shop README. Report any missing item and whether an optional dsh.catalog section is present.

  • Inspect saved proof artifacts from the offline math run

    Run the offline math fixture to see proof checks, rejection and saved manuscript files.

    View prompt
    In the repo liyingze07-svg/EffectiveAutoResearch-EAR-, run `python3 -m ear math run --offline --workspace workspaces/math-demo --episodes 1` and then `python3 -m ear math status --workspace workspaces/math-demo`. Report the status output and the saved artifact list. Verify that the run is labeled offline_demo and accepted=false before saying anything about its contents.

  • Pick benchmarks for testing a self-improving agent

    Shortlist RSI-specific and proxy benchmarks from the list to test an agent you are building.

    View prompt
    Using the Benchmarks & Evaluations section of the awesome-rsi README at lobehub/awesome-rsi, shortlist three to five benchmarks for an agent that updates its <update target>. Label each as direct RSI evaluation or capability proxy and give one reason per choice. Verify that every benchmark name and link is copied from the README.

  • Have a main agent delegate bug work to parallel chats

    Use one coordinating conversation to split a bug into investigation, fix, and test conversations.

    View prompt
    In the LodyAI/Lody repo, act as the coordinating conversation for the bug <bug-description> in the workspace <workspace-name>. Create or reuse child conversations for investigation, implementation, and testing, then report each child conversation's status. Verify the statuses against the output of `npx lody session list --workspace <workspace-name>`.

  • Vet browser and desktop control Jev projects safely

    Compare Jev-driven browser and desktop control projects before running any of them.

    View prompt
    Using the Browser & OS Action category at https://logicrw.github.io/awesome-jev-projects/en/categories/browser-os-action/, compare the candidates for <task>. Expected output: a table with project name, Jev's role, execution owner, and license. Verify that each candidate's execution and confirmation behavior is stated in its entry before you recommend it.

  • Fan a question out to several agents with best-of-n

    Run the shipped best-of-n workflow to collect and compare multiple agent answers.

    View prompt
    In the longsurf-ai/endo repo, run the /best-of-n workflow on <my question> from the Endo chat. Expected output: a Workflow card listing each agent call and the candidate answers. Verify that calls from more than one provider appear before you accept a result.

  • Turn a plain-language watch rule into a Tea monitor

    Describe a market condition to your agent and get a Tea monitor that checks incoming data and investigates when it fires.

    View prompt
    In the openchart repo, create a Tea monitor that watches for <condition> on <symbol> and investigates when it fires. Expected output: a monitor definition that evaluates incoming data and triggers an investigation. Verify by checking that the monitor compiles and that the condition matches the rule I described.

  • Summarize graft dose findings for a red-team report

    Turn the README's measured robustness results into a memo that separates results from roadmap.

    View prompt
    Read the Results section of the README and docs/TECHNIQUE.md sections 6.6 and 6.11 in the repo lordx64/phantom-kv. Write a one-page memo for <team name> with each number cited to its source line and a separate list of caveats and roadmap items. Expected output: a memo with no numbers that are missing from the source. Verify that each figure in the memo appears in the README or the cited section before finishing.

  • Get answers about your records from an AI advisor

    Chat with an AI advisor that answers from your own records, using your own OpenRouter key.

    View prompt
    In the aurelio-finance repository, after setting OPENROUTER_API_KEY in backend/.env, ask the Ask Aurelio chat <target question about my records> and report the answer. Verify that any proposed change appears as a card and that no change is saved before I confirm it.

  • Find public full text for a DOI paper

    Discover public PDF candidates for a DOI and import the root paper when one eligible copy exists.

    View prompt
    Use the papergraph-mcp repo to discover public full-text candidates for DOI <doi>. Return the candidates with their sources and do not import anything until the user chooses one. Verify that no file was downloaded during discovery.

  • Audit past lot use with the scrubbing timeline

    Replay past occupancy by second and open snapshots of each state change.

    View prompt
    For the repo lotvulture/lotvulture running at http://localhost:8000, use the Visual Scrubbing History Timeline to list the occupancy transitions for space <space_name> between <start_time> and <end_time>. Return the transition times and states, and verify that each listed transition has a matching snapshot.

  • Dictate text into any Mac app with a held key

    Hold a key, speak, and have your words pasted where you type, in any app on the Mac.

    View prompt
    Using the Louis-CFM/coucou repo, enable Flow dictation in the Coucou Mac app and set it to use Parakeet on <target Mac>. Expected output: a short spoken sentence is pasted into a text field in another app. Verify that the clipboard contents from before the dictation are restored afterwards.

  • Package an agent so teammates can install it

    Export a configured agent with its tools and skills as a .rawpkg for your team.

    View prompt
    Export the configured agent <agent-name> from the repo lploc94/raw-cli as a package named @<owner>/<name> version 1.0.0, pack it into <file>.rawpkg, and list the steps the recipient needs to bind their own model. Expected output: a packed .rawpkg file and a short recipient checklist. Verify the package file exists and contains no literal API keys.

  • Search all DEX files in an app in a single query

    Query several APK or DEX inputs together to find code spread across split or multi-DEX builds.

    View prompt
    Using the dexsql CLI, query <APK or DEX path 1> and <APK or DEX path 2> together for the method <method name>. Report which input files contain a matching method and state any method that appears in only one file.

  • Test two candidate models before choosing one

    Run both candidates as cheap exploratory runs and record why one was selected.

    View prompt
    Use the Modeling Workbench repo in <tool folder> to compare two candidate models for the problem in <project folder>. Record an exploratory run for each candidate, select one with a written rationale, and run the model-design check. Verify the comparison table lists both candidates and the selected one cites its runs.

  • Expose the unstated premises in a draft argument

    Use a red-team review to find what a conclusion leaves unsaid yet relies on.

    View prompt
    Use the Luciole-Studio/Misaka-Agent repo to run /research on this draft argument: <draft argument>. Expected output: a red-team review and a divergence review listing unstated premises and gaps in the conclusion. Verify that each listed presupposition has a recorded response in the node's files.

  • Shorten long command logs and passing test output for the model

    Removes clearly unneeded progress lines and repeated notices from command output while keeping failures and summaries.

    View prompt
    Using the repo luobosibing2/dsh-jev-plugin, enable Long-log admission and Test-log admission in a DSH profile named jev, then run <target test command>. Report which passing details were removed and confirm the failures and summary remain. Verify that the original-output recovery reference is present.

  • Compare Codex and Claude Code on the same capture

    Run the same capture with both supported agents and compare the resulting poses.

    View prompt
    In the agenticSTAR repo, run tools/run_kf.sh on examples/garden_shears/capture:0 once with --agent codex and once with --agent claude. Expect two runs/ directories, each with mesh/pose.json. Verify that both runs finished or hit their timeout before comparing outputs.

  • Score tickets or traces on your own rubric

    Place a ticket or agent trace on a 2 to 10 level rubric and get the level and expected score.

    View prompt
    In the agent-jev repository at <repo-path>, score each item in <items-folder> with a score question built from the rubric in <rubric-file>. Return level, score, and the full distribution for each item. Verify that every level is within the rubric range and that score matches the weighted sum of the distribution.

  • Build a collision-ready 3D scene from a GLB file

    Import a GLB environment, align it, add collision geometry and confirm the physical response.

    View prompt
    In the ManfredCh/Lyapunov repo, import the GLB file <path-to-glb> into a new scene, prepare static collision geometry aligned with it, and apply it to the current world. Report the scale and orientation checks and the saved scene name. Verify the physical result by checking the world response after reopening the scene.

  • Unit-test classification code without a running server

    Run your tests against a built-in fake so CI does not need Laya or Docker.

    View prompt
    In the marcreichel/laya-php repo, write a test for <class that calls Laya> that uses the built-in fake to return <expected answers>. Report the test result and the call count, and verify that the test passes with no laya-serve running.

  • Have the agent call and book a table

    Approve a request by text and let the agent phone a business for you.

    View prompt
    In the open-instinct repo at <repo path>, with the iMessage line already connected, ask the agent to call <business> to book <time>. Expected output: one text back with the call outcome and any follow-ups. Verify that you approved the call before it was placed.

  • Triage the customer inbox with drafted replies

    A Customer Satisfaction Employee sweeps your inbox and drafts replies, hardest cases first.

    View prompt
    Using the ai-employees repo, install the Customer Satisfaction Employee into <target folder> and confirm it sweeps the inbox on schedule. Expected output: replies drafted hardest first and churn flags with evidence. Verify that no reply is sent until you approve it.

  • Keep dsh sessions running across several Command Code accounts

    Add more than one account so requests move to the next one when a usage limit is hit.

    View prompt
    Configure the Mars-Sea/dsh-commandcode-provider account list in dsh with the keys for <number> accounts and confirm the active account in the settings page. Expected output: each account listed with its key status. Verify that a request continues after the first account is at its limit.

  • Triage source code findings and export SARIF

    Review code-scan findings mapped to file and line, then export them as SARIF.

    View prompt
    Using the repo martian56/redcell, create a code-scan session for <repo url or local folder path> and run it. Expected output: a SARIF file where each finding has a file and line. Verify that no dismissed finding appears in the export.

  • Triage new issues on a schedule

    Set a recurring job so the farm sorts new issues every weekday morning.

    View prompt
    Using the clodfarm repo at github.com/matank001/clodfarm, set up a recurring task that triages new issues on <repo-url> every weekday at 9. Confirm the schedule exists, then report the result of the first run in the farm UI at http://localhost:8080.

  • Audit assistant answers from conversation transcripts

    Read real conversations with citations and log answer-quality fixes in the tracker.

    View prompt
    In the ciele repository, review the conversation inbox for <assistant name> and list the five weakest answers with their citations and the source each one used. Report them as a table with suggested knowledge fixes. Verify that each listed answer links to a real transcript before reporting.

  • Fix a bug with a failing test before the fix

    Diagnose a bug in phases, then drive a red-green-refactor loop to fix it.

    View prompt
    In the mattpocock/skills repo, use diagnosing-bugs on this failure: <bug description>, then use tdd to write a failing test before any fix. Expected output: a root-cause note and a red test that turns green after the fix. Verify that the test fails on the unfixed code before you accept the change.

  • Check a workflow ledger's health before trusting its history

    Run a counts-only doctor check on a SQLite task ledger and read its exit code.

    View prompt
    Using the MaxHu-xuan/task-state-guard repo, run the doctor command against <ledger-path> and report the aggregate counts and the exit code. Verify that the output contains only counts and no task IDs, prompts, or message bodies.

  • Audit desktop packaging, signing and CI config

    Check a desktop JVM build for packaging, code-signing and CI traps before a release.

    View prompt
    Using the desktop-and-build-footguns skill from kotlin-footguns, audit the build and CI files at <project path>. Expected output: a table of matched traps with file and line, and a verification result for each. Verify that every verification command you run is one the trap file lists, and that you did not invent any new command.

  • Test the firmware in QEMU without a board

    Run the ESP32-S3 firmware in QEMU to check the tank logic before flashing real hardware.

    View prompt
    Use the mediacutlet/pocket-tank repo. Follow the 'Try it: firmware in QEMU' section to build and boot the firmware in QEMU, then report whether the tank screen renders and which goal the first fish selects. Verify that the boot finishes without a crash.

  • Carry your preferences and procedures into new sessions

    Keep your language, tone, and checklist habits available to the agent in every new session.

    View prompt
    Use the MemoraX Code skill to remember my preferred result format and my review procedure for <task type>. In a new session in <project path>, apply both before you answer and list which saved preference and procedure you used. Verify that the procedure's validation gate is stated in your answer.

  • Compare replies with native memory on and off

    Run the same question with memory reading disabled to see what the memory layer changes.

    View prompt
    Use the MemTensor/MemT-1.0 repo with a running MemT-1.0-Nano server to ask <question> with memory reading on and off. Expected output: two answers, where only the memory-on answer uses facts from the saved conversation. Verify that the memory-off session was created without restoring a snapshot.

  • Manage Gmail, Calendar, and Contacts by text

    Connect a Google account so the assistant can work with your email, events, and contacts.

    View prompt
    Using the repo Merit-Systems/OpenInstinct, create and attach a Google connector for the project <project> and set GOOGLE_CONNECTOR_UID. Expected output: the connector UID and a redeployed app. Verify that the credential file was deleted and that no credential file is staged in git.

  • Adapt the harness bank to a new task domain

    Use the bundled evolution skills to build student and reference harnesses for another domain.

    View prompt
    Using the repo metaevo-ai/harness-zero, study harness_bank/uspto and the skills in .agents/skills/, then draft a new harness_bank folder for the domain <domain-name>. Expected output: a folder layout and a short plan listing the student harness and reference harness files. Verify that the plan matches the existing per-domain structure before writing any files.

  • Tune a theory paper's stance, keep theorems and assumptions

    Adjust contribution wording in a theory paper while leaving formal statements unchanged.

    View prompt
    Use the game-the-llm-reviewer skill from Michael-Jiahao-Zhang/game-the-llm-reviewer on paper/main.tex in <path to project>. Adjust contribution stance only, and preserve theorem assumptions, quantifiers, and the distinction between an upper bound and an optimal rate. Verify with a diff that no theorem, lemma, or assumption text changed.

  • Collect records that match filters in a web table

    Have Jevry apply filters to a catalog or admin table and report the matching records it found.

    View prompt
    Use the repo michaelswissa/jevry: after npm run dev, ask the desktop app to find records on <table-url> matching <filter>. Expect a list of records; verify the count against the table's own total and confirm every result page was read.

  • Capture a terminal workflow as a Skill with native tools

    Record commands run in the app's recorded terminal and turn them into a Skill that uses native tools.

    View prompt
    Use the Skill Recorder repo at microsoft/skill-recorder to convert my terminal session for <workflow> into a Skill. Expected output: a SKILL.md that calls native tools such as the gh CLI instead of replaying keystrokes. Verify that no secrets appear in the generated file.

  • Watch your 5-hour and weekly usage at a glance

    Install Sub Meter to see subscription usage bars in the bottom right of Claude Code.

    View prompt
    In Claude Code on a subscription account with the better-claude sub-meter plugin installed, check the bottom right of the window for the 5-hour and weekly usage bars. Expected output: two bars showing current usage in each window. Verify that both bars are visible after restarting the session.

  • Type text into the TV from your laptop

    Use your laptop keyboard to fill in on-screen keyboard fields on the TV, including hidden passwords.

    View prompt
    In the tv-home repo, run tools/type.sh with the TV at <tv-ip> focused on a text field, using the text supplied by the user at run time. Report whether the text was entered. Verify by taking a screenshot with tools/tv.py and confirming the field shows the expected length without displaying a password in logs.

  • Clone a public GitHub repo and inspect its run diagnostics

    Bring a public GitHub codebase into a FOREST project and check the source commit and run diagnostics.

    View prompt
    Using the FOREST CLI in <repo path>, clone the public repository <repository URL> into the selected project and wait for it to finish. Then run the inspect and diagnostics commands on the returned run ID and report the source commit. Verify that the commit reported by inspect matches the commit you expected from the repository.

  • Review token use and cost by agent and model

    Filter usage by date, agent, model, or provider to see where tokens and estimated spend went.

    View prompt
    Use the agentacct repo at https://github.com/mikehasa/agentacct to report token totals and estimated cost by agent and by model for the last 7 days on this machine. Verify that cost figures are labeled as estimates and that the local data freshness stamp is shown.

  • Connect a custom domain and transactional email

    Point a domain you own at the live app and set up sending through Resend.

    View prompt
    Use the golive skill in the repo <repo-path> to plan a custom domain DNS change through Porkbun or GoDaddy and transactional email through Resend. Show the zone and each record in the plan before any write, then report what was applied and what remains manual.

  • Let a bot work on your Mac with approval on each step

    Point a bot at your own computer and approve or deny each risky action as an inline card.

    View prompt
    Using the OpenMausBot repo at github.com/milind-soni/OpenMausBot, set up one bot to run the task <task-description> on this Mac after explicit host control opt-in. Expected output: a log of each approval card and the decision made on it. Verify that no action ran without a recorded Allow.

  • Run agent Sessions on your own Linux, macOS or Windows machine

    Add a personal machine as sandbox capacity so Sessions run on hardware you own.

    View prompt
    Using the MiniMax-AI/OpenAgentCore repo, set up Core and Web on <target machine>, add that machine as sandbox capacity in Web, and start one Session that writes a file to /workspace. Report the Session ID and confirm the file exists on the machine after the Session completes.

  • Audit existing code and remove AI-slop comments

    Run antislop in After mode to get a numbered list of comment fixes you approve.

    View prompt
    Using the antislop-code rules from the anti-slop repo (https://github.com/miqdadbadjuber/anti-slop), audit the comments in <project-folder>. Return a numbered findings list, then wait for approval before editing. Verify that no approved fix changes code behavior, only comments.

  • Train the renderer on your own depth and normal clips

    Fine-tune the neural renderer on your own clips listed in a JSONL manifest.

    View prompt
    Using the AgentGarten repo at <repo path>, create a JSONL manifest from the clips in <clips folder> with depth and normal files, then launch bidirectional training with scripts/run.sh. Expected output: training logs and checkpoints written under the output root in .env. Verify that the manifest has one valid line per clip and that the first training iteration starts before reporting success.

  • Run the bundled ballistic soccer MuJoCo simulation

    Render a soccer-kick trajectory from the video-driven abstraction example in a few commands.

    View prompt
    In the Code-as-World repo at <repo_path>, install requirements/simulation.txt and run `python -m code_as_world.simulation` to execute the bundled ballistic soccer case. Expect a rendered video and trajectory in outputs/simulations/; verify both files exist and that the trajectory file is non-empty.

  • Run the bundled demo to test the setup end to end

    Use the included example results to confirm the install works before you bring your own model outputs.

    View prompt
    In the HarnessEval-W repo, complete the setup from docs/installation, activate harnesseval-main, then run the bundled demo from runs/example/results_example with harnesseval eval and harnesseval verify run. Expect a summary.json under run/harnesseval/models/seedance-2.0-standard/evaluation. Verify that the verify command reports all scores present before saying the setup works.

  • Review a screen design for foldable poses and fold avoidance

    Critique a mockup or screen for pose behavior, side controls, asymmetry and sheets without writing code.

    View prompt
    Using the iphone-duo-design-review skill from mirzaaghazadeh/iphone-duo-skills, critique the screen described in <path-to-design-notes-or-image> for how it behaves across iPhone Duo poses, with attention to side controls, asymmetry, fold avoidance and sheets. Output a prioritized list of issues with one suggested change each, and verify that the critique does not assume a specific framework.

  • Submit a reviewed run from a manifest

    Apply a checked run.toml file so the same task runs the same way every time.

    View prompt
    In the ESF repo at <esf_path>, read <manifest_path>, confirm it names an allowed repo, a full commit SHA, and a configured agent harness, then run `./bin/factory apply -f <manifest_path>`. Report the resulting run ID and one thing to verify in `./bin/factory describe run <RUN_ID>` before trusting the output.

  • Send prepared prompts to ChatGPT with Zero Risk mode

    Use a manual paste-and-send flow when you do not want the launcher to operate the ChatGPT page.

    View prompt
    Using the codex-chatgpt-web repo, prepare a Zero Risk prompt for <task description> and list the exact model and Codex Zero Risk connector the user should select. Expected output is the prompt text and a checklist of manual steps. Verify that you did not send the prompt yourself and that the user confirms Sent in the launcher afterward.

  • Check commit messages and staged changes against AGENTS.md

    Judge each commit message against its diff and each change against repo instructions.

    View prompt
    In the repository <repo-path>, with TYPESAFE_API_KEY set, run `npx jev-lint commits --base main` and then `npx jev-lint commits --staged`. Report each finding that cites an AGENTS.md instruction or a commit message mismatch, and confirm each cited instruction exists in the file.

  • Watch a local Snake agent make live decisions

    Run the terminal Snake demo where Laya picks every move on your Mac.

    View prompt
    In the laya-mlx repo (github.com/mizorewww/laya-mlx), install the demo extra and start the laya-snake terminal game in a terminal of at least 104 by 35 cells. Report the moves per second shown and whether any safety intervention occurred. Verify that the game runs without an external API key or network call during play.

  • Pick up a coding task after the chat compacts

    Keep edits, tasks, and decisions in SQLite so the agent can recover them after compaction.

    View prompt
    After a context compaction in the <project-name> repo, use context-mode to search the session events for the last edited files and open tasks. List them and ask me to confirm before continuing the work.

  • Compare a shortlist of products by the specs that differ

    Line up up to 10 Digikala products and see only the specs that actually differ.

    View prompt
    Use the Digikala MCP server at https://digikala-mcp.mmdju.workers.dev/mcp. Take these product ids: <comma-separated ids, up to 10>. Call get_products_batch, then compare_products, and return a table of only the differing specs with price in Toman. Verify that no product is missing from the table.

  • Run the agent 24/7 on a VPS with health checks

    Deploy the PM2 daemon, check diagnostics, and update the agent on a Linux server.

    View prompt
    Using the noraz-agent repo on a Linux VPS, run `noraz deploy` and then `noraz doctor`. Expected output: PM2 shows noraz-agent as online and the doctor report lists no failed checks. Verify the result with `npx pm2 status` before reporting success.

  • Pick the right search endpoint from the catalog

    List and inspect web-search endpoints across providers before choosing one.

    View prompt
    In the monid repo, run deno task catalog endpoints --category web-search and then deno task catalog inspect on the two most relevant endpoints for <your search goal>. Report a short comparison of their inputs and descriptions.

  • Trace calls in a running program with Frida

    Inject scripts into a process you are authorized to test to observe its behavior.

    View prompt
    Using the morluto/awesome-reverse-engineering list, confirm that Frida is listed under Dynamic instrumentation and tracing, then outline a Frida hook plan for the process <target-process>. Expected output: a short plan listing the functions to hook and what to log. Verify that the plan only targets a process the user is authorized to test.

  • Let an agent find and run a graph or SAT operation

    Use math.find to match a graph or SAT question to a bounded operation, then run it once.

    View prompt
    Using the Jacobian MCP server from morluto/jacobian, use math.find to match this need: <problem description>. Inspect the best operation, call math.run once with <input>, and return the typed result. Verify that the result states whether it is exact, approximate, or incomplete.

  • Give a portrait a film or camera-device look

    Apply a color grade and capture response such as 35mm negative or instant film while keeping the view and focus.

    View prompt
    Using the xxg-portrait-rebuild-light skill from moskoo/xxg-portrait-rebuild-light, apply G7 color grade and D3 capture response to the portrait at <path to portrait>, keeping viewpoint and depth of field. Return the edited image, and verify that the crop, focus, and skin tone match the source apart from the requested grade.

  • Repair weak image-to-video clips in a poem project

    Find clips with broken animals, rebuilt buildings, or bad transitions and redo only those clips.

    View prompt
    Use the classical-poem-silk-video skill from https://github.com/Mr-funny/hbg-classical-poem-silk-video to review the image-to-video clips in <project folder>. Name each failing clip and rebuild only those clips without changing the camera. Verify with final_media_qa.sh that the rebuilt final MP4 has no black frame at the transition midpoints.

  • Learn how the skill builds isometric SVG from SKILL.md

    Read the skill kernel and examples to see how box faces become SVG matrix transforms.

    View prompt
    Clone the MrBongoC/ai-iso-skill repo, read skills/iso-figure/SKILL.md and the files in examples, and summarize how box faces become SVG matrix() transforms. Expected output: a short written explanation with file references. Verify each claim against the actual files.

  • Let agents work across Notion, Gmail and Slack

    Connect Notion, Gmail or Slack in one click so agents can act on the messages and pages you use daily.

    View prompt
    Using the Nami repo at mrdainami/nami, connect the Gmail account for <target-account> and ask an agent to summarize the last five messages in one thread. Expected output: a short summary of those five messages. Verify the agent made no send, delete or edit action.

  • Screen existing drafts for account-risk signals before posting

    Run the pre-publish risk gate on drafts you already wrote to catch leaks, bait and duplicates.

    View prompt
    Using the yominpost repo at github.com/mrlong0129/yominpost, run check_post on each draft in <your draft file or list> and report the findings. Expected output: one risk result per draft. Verify that the findings name the rule that fired, such as hashtag limits or duplicate detection.

  • Send a structured bug report when a label looks wrong

    Let an agent file a feedback.now report when classification breaks or misbehaves.

    View prompt
    Using the feedback.now endpoints at https://classifier.dev described in the classifier-dev repo, file one report for <describe the wrong label> with the input text and the returned label as evidence. Output the report id and the receipt status. Verify that the receipt shows the report was accepted or marked as a duplicate.

  • Operate a native desktop app by its accessibility tree

    Drive native UI through Windows UIA or macOS AX using observe, candidate, execute, and verify steps.

    View prompt
    Use the nuphus-mcp semantic desktop tools to bind the window titled <window title>, pick the element labeled <element label>, and perform <action>. Return the verified state as text. Verify the state with desktop_verify_state before reporting success.

  • Check a certification file before submitting it

    Run the type-check, build, and lint steps on a new certification file before opening a pull request.

    View prompt
    In the mrtinkz/ai-charter repository, place the certification file <file name>.json in src/data/certifications/, then run `npm run build` and `npm run lint`. Expected output: both commands finish without errors. Verify with `npm run preview` that the model appears on the /registry page.

  • Test whether System 2 observers help a task

    Build a System 1 brain and a recursive brain with observers, then compare them on the same task.

    View prompt
    Using the Python package cadence-net (repo muellerberndt/cadence), run Brain.compose with and without observers=(8,) on the environment at <task file> using live() for 500 steps each. Expected output: two reward-by-step series and a summary of their averages. Verify that both brains receive identical observations and rewards at each step.

  • Run DeepSeek-V4.1-Flash locally with picture input

    Set up DeepSeek-V4.1-Flash-1017 on your GPUs and include vision support for images.

    View prompt
    Use the GitHub repo mw00/project-maya. On <target machine>, run ./setup.sh --model DeepSeek-V4.1-Flash-1017 and then ./maya.sh --bench. Expected output: benchmark numbers for the DeepSeek model and a successful image-plus-text answer. Verify that the vision component loaded (the setup should report it) before counting the test as passed.

  • Get a timeline or before-and-after picture in a reply

    Use figure blocks to draw position-based pictures such as timelines, screen layouts and before-and-after comparisons.

    View prompt
    With the NahumLitvin/prismantis plugin active in Claude Code, ask Claude to show <scenario> as a figure block. Expected output: a text picture drawn in theme colors with no raw markup. Verify that a role such as warn or ok colors the right run and that the copy source button returns the markdown block.

  • Look up the commands that failed last time

    Filter past Bash and MCP calls to only the failures so you do not repeat known traps.

    View prompt
    Using the session-knowledge repo, call find_tool_call with a query for <command or service> and errors_only set to true. Expect past failed calls with their arguments and results. Verify the arguments before rerunning any command.

  • Draft a blameless postmortem with the Codex plugin

    Write a postmortem that names mechanisms, timestamps, and owned action items.

    View prompt
    Using the sepia repo, run its write operation to draft a postmortem from <timeline notes file>. Expected output: a postmortem with timestamps, dead ends, and owned action items. Verify that every timestamp matches the timeline notes.

  • Send a task from your phone to your computer

    Start a message with an @ device name on the phone so the desktop app does the work there.

    View prompt
    In the nano-muse/nanoMuse repository, install nanoMuse Desktop v1.0.5 on <computer> and sign in with the account used on <phone>. Send one harmless test task from the phone starting with @Mac, and verify the desktop reports the task as started.

  • Generate scroll-page imagery and video with a KIE key

    Add KIE_AI_API_KEY so the agent can generate scroll-page assets instead of using only your own media.

    View prompt
    Using the scroll-craft skill in the nateherkai/scroll-craft repo, generate the hero assets for <target brand> using KIE_AI_API_KEY from the local env file. Expected output: generated image and video files for the page. Verify that the key is read from the environment and never written into HTML or committed files.

  • Claim a code area so other agents see ownership

    Mark which agent is working on a symbol, with an advisory lease that never blocks anyone.

    View prompt
    In the <repo path> repository, have two registered agents claim symbol:<target> with separate intents and reasons. Expected output: both claims succeed and the second response includes an overlap warning. Verify that advisory_only is true in the claim data before you tell anyone the scope is owned.

  • Have a coding assistant install and check GPT with Taste

    Give a coding agent the repo and install guide so it handles setup.

    View prompt
    Use the repository at <repo-path> and follow docs/install-for-ai.md. Run `node scripts/check-updates.mjs`, then install with `node scripts/install.mjs --hooks`, and list every file written under the active CODEX_HOME. Verify that the hook definitions are still untrusted until a person reviews them under Settings → Hooks.

  • Verify that a security fix really closes the finding

    Use a separate read-only agent to give a per-finding verdict on whether a fix worked.

    View prompt
    Using the VulnHunter repo at nealbridges/VulnHunter, run the /vulnhunt-fix-verify skill on the findings <finding IDs> in <target repo path>. Return one verdict per finding, stating whether it was remediated. Verify that the verifier made no code changes, since it is described as read-only.

  • Have a room's model build and fix a small app

    Switch a room to Code mode, describe an app, and let the model write, preview and fix it in the tab.

    View prompt
    Using the Nehanth/pooled repository, open a room in a browser tab, switch to Code mode, and ask for 'build a tetris game'. Expected output: a set of files and a running preview on port 5173. Verify that the preview runs without console errors after the model's fix step.

  • Choose a chibi form for a high-density sticker set

    Select a compact body form with the right head ratio for stickers and gag panels.

    View prompt
    Using the Neko3000/deepseek-whalechan repo, generate a <number> image sticker set of Whale-chan in the chibi form through the whalechan-image-character skill. Output the WebP files and their head-ratio check results. Verify that each image is inside the 2.372 to 2.672 head-ratio band for chibi.

  • Open ChatGPT with terminal access to a project

    Open ChatGPT in the browser with terminal access to the current project or a folder you name.

    View prompt
    Using the WebGPT repo (Nhahan/WebGPT), run `webgpt open /path/to/project` with the project path <project path>. Expect ChatGPT to open with terminal access to that folder. Verify the session is pointed at the correct project before giving it any task.

  • Refactor in scored steps until deltas plateau

    Use previousEvaluation so the agent sees which dimensions improved or regressed.

    View prompt
    Refactor <module path> with the jev_review tool from NiazMorshed2007/jev-review. Call it for a baseline, then after each change call it again with previousEvaluation set to the prior result. Report the per-dimension deltas and any regressions, and confirm that the project's existing tests still pass after each step.

  • Check subscription quota before routing a task

    Read account usage with the status command so you know which subscriptions still have capacity.

    View prompt
    In the agent-router repo, run `router status --usage` and list each account with its quota and whether it is eligible. Verify that shared accounts show their reserve and that no personal account is excluded only because quota is missing.

  • Have an agent research and test sites in its own browser

    Let a persistent agent open, inspect, and control the embedded browser for web research or QA.

    View prompt
    In the nightly-labs/openbot repo, create an agent in the desktop app and ask it to open each URL in <url-list> in the embedded browser and report the page title and any visible errors. Expected output: a per-URL list of results in the agent's conversation. Verify that every URL was opened before reporting success.

  • Adapt the course for a new audience and keep the license

    Run the course locally, edit chapter material, and check it with the production commands.

    View prompt
    In a fork of NiluK/worldmodels101, edit one chapter for a new audience while keeping credit to Nilushanan Kulasingham and World Models 101. Run `pnpm lint` and `pnpm build` and report the results, then confirm the license file is unchanged and still says CC BY-SA 4.0.

  • Check that a Python bug fix really fixes the bug

    Require the offered tests to fail on the old code and pass on the new tree.

    View prompt
    In the no_human repo, add the Python bug issue <issue-url> for the repo at <local-repo-path> and run nh review. Report whether the reproduction gate passed, and state which test was offered as evidence.

  • Walk through a Helix World scene in the browser

    Open the hosted demo to hear how sound changes as you move and turn, with no local setup.

    View prompt
    Open https://helixworld.org/ in a browser, move forward and turn in one scene from the HelixWorld project (NoizAI/HelixWorld), and report whether the sound changes with the viewpoint. Expect a short written note; verify that the note states the scene name and the observed sound changes.

  • Share one decision endpoint with a capped reasoning budget

    Run a local HTTP gateway so several clients get decisions and share one cap on reasoning escalations.

    View prompt
    Using the repo AnyJev (nokia-applied-research/AnyJev), start the vLLM server for morriszjm/Tacit-9B and the anyjev.serve gateway on port 8100, then POST the decision <state text> with options <option list> to /v1/decide. Expected output: a JSON decision with answer, probs and route fields. Verify that GET /v1/stats returns an escalation share at or below the configured cap.

  • Let a coding agent drive a running studio from the terminal

    Use cclay live commands so a coding agent can read and change a studio session with JSON in and out.

    View prompt
    Using the NomaDamas/CozyClay repo, run `cclay live status --wait` against the open studio and then apply <scene change> through the live terminal interface. Expected output is JSON that shows the updated scene state. Verify that the status reports a ready studio before any edit is sent.

  • Get a monthly spending summary and budget

    Use the built-in monthly-summary and build-budget prompts to review last month's spending.

    View prompt
    Using the repo noskillish/bankmcp, run the monthly-summary prompt for <month and year> on the account labelled <account label>. Expected output: a summary of income and spending for that month. Verify that one category total matches the transactions listed by get_transactions.

  • Summarize Sentry's recovery findings from the paper

    Read the arXiv paper and extract the reported results and design claims.

    View prompt
    Read the Sentry README at github.com/nuglifeleoji/Sentry and the paper at https://arxiv.org/abs/2610.02994. Write a one-page summary of the reported results and design claims relevant to <research-question>. Verify each number against the paper text, not only the README, and flag any number you cannot find there.

  • Run the structural pass on a long draft or story

    Check discourse structure with six audits, then vary the shape so the piece is not a new template.

    View prompt
    Using the humanizer-stack repo at <repo path>, run the structural_scan.py script on <draft file> and then apply the structural-humanizer skill audits that apply to this genre. Output a revised draft and a list of the audits that changed text. Verify that at most two interventions were applied in this piece and that each one is explained.

  • Write indexer output to a JSON snapshot instead of Postgres

    Point the indexer at a JSON read model path to capture decoded account data without running a database.

    View prompt
    In the NuvexNetwork/nuvex-services repo, set NUVEX_RPC_URL, one program id, and NUVEX_READ_MODEL_PATH=<snapshot-path> in .env.local, run the indexer, then open the snapshot file. Report the number of top-level records and list the first record's keys. Verify that the indexer did not invent rows by comparing record count to the program accounts the RPC returned.

  • Have an Agent draft a Context Doc that you review

    Let a scoped Agent propose edits to a versioned document, then review the operations before they stand.

    View prompt
    Using the EverRoom repository at <repo path>, read the Context Docs and Agent sections of README.md. Produce a short procedure for asking an agent to draft a section of <document name> and reviewing its edits. Verify that the procedure says edits are reviewable and committed through the document kernel.

  • Generate spoken narration audio from a text file

    Turn a script into a WAVE file of speech using a local Qwen3-TTS voice.

    View prompt
    Using the nyosegawa/speech.cpp repo, install speech and run `speech tts qwen3-tts-0.6b --voice ryan -o <output>.wav "<script text>"`. Expected output: a WAVE file at the path given, with the script spoken in the ryan voice. Verify that the file plays and matches the script.

  • Isolate agent work on a branch and finish it cleanly

    Keep agent changes in their own worktree and branch, then merge, open a PR, keep, or discard them.

    View prompt
    Using the Superpowers skills from the obra/superpowers repo, create an isolated worktree on a new branch for the approved change <change name> in the project at <project path>. Expected output: a new branch with a clean test baseline and, at the end, a finishing-a-development-branch summary of the options. Verify that the test baseline result is reported before any code is changed.

  • Look up rules across project, vendor, user, and system scopes

    Find a concept in the right layer, with higher-priority scopes shadowing lower ones.

    View prompt
    Using the okf-memory/okf-agent-memory repo, search for <topic> across all scopes, then show the concept the search ranks first. Report which scope it came from and whether a higher-priority scope shadows any other matching concept. Verify the scope label before using the concept.

  • Pin a city street photo using public street-tree data

    Use a city's open street-tree records and street features to find the block in a street photo.

    View prompt
    Use the geo-sleuth skill from the Oldcircle/geo-sleuth repo to find the block where <path to street photo> was taken, starting from public street-tree data for <city>. Expect a block with an error of a few metres and a list of the trees and checks behind it. Verify that each claim names the file or command that supports it.

  • Track who is home and whose car is in the drive

    Get on/off sensors for named people and your own car from a driveway camera.

    View prompt
    Using the VisionState repo at https://github.com/oleost/VisionState, set up object and person sensors for the camera <camera_entity>, with named people <person_names>. Expected output: an on/off sensor for each named person and for the car object. Verify that face recognition is enabled only for the camera you chose.

  • Route Thai or Japanese intents with a small model

    Use the Thai and Japanese decision models to score fixed intent labels for local-language messages.

    View prompt
    Using the OpenThai-SystemOne and sokudan entries in https://github.com/OmniJev/awesome-jev-gallery, map <intent labels> to a fixed option set and score a held-out sample of <language> messages. Report the label probabilities for each message. Verify that the labels cover every intent you plan to route.

  • Run a small One Jev model on a laptop with llama.cpp

    Serve the 0.8B GGUF build for text and image questions without an NVIDIA GPU.

    View prompt
    Using the OneJev repo at https://github.com/OmniJev/OneJev, install llama.cpp, then run `qev serve --gguf mradermacher/OneJev1.6-0.8B-GGUF:Q8_0 --port 8000`. Send one image with a yes/no question and return the noul probability. Verify that the request uses an image and not a video before reporting the result.

  • Let the agent query local files and SQLite through MCP

    Enable supported local MCP servers such as filesystem and SQLite for data questions.

    View prompt
    Using omnirush-gui with its SQLite MCP server enabled in Settings > MCP, query <database-path> for the row count of <table> and list its columns. Verify the row count against the source before reporting it.

  • Cut out a subject and build a Surface, Balloon, or Depth Shape

    Select a subject in an image and turn that selection into a 3D form.

    View prompt
    Using the OmooLab/AnyImage add-on in Blender, run Cutout on the subject <subject description> in the image <image name> and produce a Surface, Balloon, or Depth Shape. Expected output: a new 3D shape object in the scene. Verify that the shape matches the selected subject outline.

  • Start saved phone tasks from Siri or Shortcuts

    Trigger a saved agent task with a voice command or a shortcut instead of opening the app.

    View prompt
    Using the repo onehumanbeing/esp32-iphone-agent, check that a saved task named <task name> can be started from Shortcuts on the iPhone at <device name>. Expected output: a yes or no with the Shortcuts action used. Verify the Dynamic Island shows the run after it starts.

  • Look up security advisories for a dependency

    Query the OSV database for a GHSA, CVE, or ecosystem id and read a compact result.

    View prompt
    Use the only-cli/oc repo: run `oc osv vuln <advisory-id>` with the id from the dependency alert. Expect a compact advisory view with the affected package and versions. Verify the id in the output matches the alert before acting on it.

  • Keep model bindings working after Grok Bot updates

    Run the doctor and HUD checks so you can see exactly what a Grok Bot update changed and restore it.

    View prompt
    Using the OnlyTerp/opengrok repo, run `python tools/doctor.py` and report every item the doctor says has changed since the baseline. Then run `python tools/glass-inject.py --check` and report whether the HUD is present. Verify the report names specific files or services, not just a general healthy or unhealthy label.

  • Hand a film to Final Cut Pro, Premiere Pro or DaVinci Resolve

    Export the timeline so an editor can finish the film in a professional video editor.

    View prompt
    In the openfilm/openfilm repo, open the film at <folder> in Studio and export its timeline for <Final Cut Pro, Premiere Pro or DaVinci Resolve>. Expect an exported timeline file that the target app can open. Verify by opening it in that app and checking that track order and clip timing match the film.

  • Validate PACT messages with protocol schemas

    Check Agent Cards, messages, errors, and JWT claims against the Zod schemas.

    View prompt
    In the openpactprotocol/openpactprotocol repo, use the Zod schemas in packages/protocol to validate the sample payload at <payload-path>. Output whether it is an Agent Card, a message, an error, or JWT claims, and list any validation errors. Verify the result by running the schema against one valid and one invalid sample.

  • Map a diff's impact and generate tests for uncovered paths

    Get an impact report and runnable test files for the paths a change left untested.

    View prompt
    Use codexqa-change-analysis on the diff between <base-branch> and the current branch in this repo. Write one HTML change-impact report and add runnable test files for uncovered points without editing existing test files. Verify that the report lists which methods changed, the entries that reach them, and the uncovered paths.

  • Review a pull request on your machine before merging

    Run a full OpenQodex review on a pull request number from your own terminal.

    View prompt
    In the repo at <path>, review pull request <number> with OpenQodex and summarize the verdict and each finding. Verify that the output either names a report path or lists the stages that did not run.

  • Run Pi Bolt in your editor's agent panel

    Use Pi Bolt through the Agent Client Protocol in Zed, JetBrains, VS Code or Neovim.

    View prompt
    In the repo opensec-git/Pi-Bolt, add a Pi-Bolt agent_servers entry for Zed that runs the full path of pi-bolt with the argument --acp. Report the settings.json change. Verify that the Pi-Bolt agent appears in the Zed agent panel and can answer a short prompt.

  • Stop repeated tool runs after a crash

    Persist requests in SQLite so a repeated request returns the saved result instead of running again.

    View prompt
    Using the repo OpenSparX/MasterAgent, run `sparx run --state ./state/agent.db --session <session> --request-id <id> --input '<command>'` twice, restarting between runs, then run `sparx recover --state ./state/agent.db`. Expected output is the same recorded outcome on the second run and any unfinished requests listed as UNKNOWN. Verify that the tool was not invoked a second time.

  • Put a face on an OpenAI Realtime agent

    Wrap an existing OpenAI Realtime connection so the avatar speaks its replies.

    View prompt
    Use the openspline repo (github.com/openspline/openspline) to add the OpenAIRealtime adapter to the agent in <path-to-agent>, keeping its existing event handler. Use portrait <path-to-portrait.jpg>. Confirm the speaker output is disabled so audio plays once, and report the viewer URL.

  • Repeat a proven task across many directories on a schedule

    Run one working workflow over several folders with batch tasks, then schedule it as an automation.

    View prompt
    Use the Open Vetta repo (openvetta/open-vetta) to run a batch task built from the workflow in <workflow-name> across the directories in <directory-list>. Report, for each directory, whether the task finished and which files changed. Verify by checking that the results match the workflow on at least one directory you inspect by hand.

  • Send tasks to your bot by email, text or phone call

    Email, text or call your main bot's own address or number on Pro or Max to get work done remotely.

    View prompt
    Using the OrgoAI/bops repo, draft an email to the main bot at <bot-email-address> asking it to <task-description>. Expected output is the drafted email text and a note on whether the bot is expected to reply by email when done. Verify that the plan includes a bot email address before sending, since the README limits this to Pro and Max.

  • Build and run the iOS app on your own iPhone

    Build Community Edition from source in Xcode and run it on an iPhone with a free developer account.

    View prompt
    Open ios/Oriveo/Oriveo.xcodeproj from the oriveo/oriveo repository in Xcode 26, select the Oriveo scheme, set the signing team to <team-name>, and run on <device-name>. Expected output: the app launches on the device. Verify that the bundle identifier is registered under <team-name>.

  • Fill in a web form and confirm what the site received

    Give Scout the form details and get back exactly what the site recorded.

    View prompt
    Use the outcrawl/scout repo to build task.ts that fills in the form at <form URL> with <the field values> and reports exactly what the site shows as received. Print result.data, result.status and result.replayUrl. Verify that the status is completed and the replay shows the submitted values.

  • Decensor a larger model on a small GPU with 4-bit quantization

    Turn on bitsandbytes 4-bit quantization so a model fits into less VRAM during the run.

    View prompt
    Install heretic-llm from the p-e-w/heretic repo and set the quantization option to bnb_4bit in a copy of config.default.toml. Then run Heretic on <model-id> using that configuration. Report whether the run completed, and verify that the log shows the bnb_4bit setting was applied.

  • Run an AI VTuber with a Live2D model, streaming TTS and OBS overlay

    Use the cortico-world-vtuber project to drive a Live2D avatar, speech and subtitles.

    View prompt
    Clone https://github.com/Pal-AI-Lab/cortico-world-vtuber and set it up as a Cortico World for a Live2D model in VTube Studio. Expected output: a running World that shows subtitles in the OBS overlay. Verify that the subtitle timing lines up with the spoken audio.

  • Compare interview focus across two AI labs

    Put two company sections side by side to choose where to focus your preparation.

    View prompt
    Using the repo pallavi-shekhar/ai-engineering-interview-questions-company-wise, compare the <company A> and <company B> sections on roles covered, reported interview loop stages and topics asked. Expected output: a side-by-side table with one row per dimension. Verify that each cell is supported by text that appears in that company's section.

  • Review generated CAD with QA reports and repair history

    Inspect the brief, plan, generated Python, measurements, and repair steps behind each generated part.

    View prompt
    Use the Multi-Agent-CAD repo (github.com/Pan-Chera/Multi-Agent-CAD). Run the single-part workflow for the brief <part description>, then summarize the QA report and repair history and list any measurements that do not match the brief.

  • Govern a team's policy or course content with human approval

    Write your own knowledge as Markdown, keep it as draft, and publish only what a person approves.

    View prompt
    Using the panaversity/ksor repo in <project-directory>, add my policy document at <path-to-document> to knowledge/ as a draft, then run the build. Report the document and admitted counts before and after approval, and verify that the draft is excluded from machine surfaces until approved.

  • Let guests watch or ask before edits and commands

    Keep the host in control with approval rules or a watch-only guest mode for shared sessions.

    View prompt
    With the Paradigm-Study/claude-share plugin, open a shared session for the project at <project-path> using the default approval rules. Output the room's permission settings and the list of guests from /room. Verify that a guest request to run a command at <test-command> waits for host approval and does not run on its own.

  • Compare vLLM and SGLang on a shared-prefix workload

    Run one model on both engines to measure the TTFT gap on prefix-heavy traffic.

    View prompt
    Using the patchy631/time-to-first-token repo, run the same model with a shared system prompt on vLLM and on SGLang at <GPU host>. Expected output: a table of TTFT and throughput for each engine. Verify that both runs used the same model, prompt set, and hardware before comparing numbers.

  • Find which code writes a field that goes wrong

    Watch a field for access and modification, then read the stack at each change.

    View prompt
    Use the Debroid CLI to watch the field <field-name> in <class-name> of the app <package-name>. Run <user-flow> and then run `debroid poll --with-stacktrace`. Return each access or modification with its stack trace as JSON, and verify that the watched field name matches the one you set with `debroid points`.

  • Let a bot work in your signed-in browser

    Assign a Noodle Browser profile with your sign-ins to a bot for web tasks.

    View prompt
    Using the Noodle repo at github.com/pdparchitect/noodle, assign a Noodle Browser profile to a bot and ask it to check <website or dashboard>. Expected output: a short summary and at least one clickable preview in the conversation. Verify that the browser profile holds the sign-in the bot needs before you let it act.

  • Mark up a page an agent opened and send notes back

    Pick elements or regions on an agent's browser page and send your notes to that agent.

    View prompt
    Have the agent run `herdr-gpui browser open` on the local page it is building in <workspace-name>, then review the annotations the user adds in the browser tab. Report which elements or regions were annotated and what each note asks for. Verify that the notes were sent to the same agent session.

  • Resume a long agent session after a server restart

    Use the on-disk prompt cache so a deep agent session picks up without a cold start.

    View prompt
    Using the repo peonist-ai/halogen-flash-server, enable the on-disk prompt cache as described in docs/configuration.md and resume <target session> after a server restart. Expected output: the resumed session answers its next turn without reprocessing the full prompt. Verify by checking the time to first token against the first cold turn.

  • Block a risky Codex action with a custom deny rule

    Copy a shipped rule, mark it enforce: true, and install it on a Codex pre-action hook.

    View prompt
    Use the repo perplexityai/numbat. Copy the shipped YAML for <rule-id> from rules/ into ./numbat-policy, set enforce: true and a new version, then run `numbat rules check --rules-dir ./numbat-policy`. Report whether validation passes and which rule ids are active. Verify that the enforcement record uses mode "enforce" only for the rule you marked, and that all other shipped rules remain monitor-only.

  • Build the SPACE guide and API docs on your machine

    Build the mdBook guide and API reference locally and browse them in a browser.

    View prompt
    In the perplexityai/SPACE checkout, install mdBook 0.4.52, run `bash scripts/build-docs.sh`, then serve target/docs/site on 127.0.0.1 port 8000. Report the build result, and verify that the page at http://127.0.0.1:8000 loads.

  • Block risky commands with rules and a stricter fallback

    Use riskRules, fallbackPolicy, and riskPolicy in cordis.yml to deny dangerous requests automatically.

    View prompt
    Using the repo PerryLink/dsh-auto-review, edit the auto-review row in the cordis patch for profile <profile-name> to add a riskRules entry that sets policy never for the pattern <regex>, then verify with dsh --profile <profile-name> --dump-config that the entry is present. Report the final config block. Verify that the config is written in the profile patch and not in ~/.dsh/settings.yaml.

  • Build company research cards from your own data files

    Turn Markdown, text, CSV, TSV, or JSON files in the workspace into company cards with explicit gaps.

    View prompt
    Using the dsh-industry-research plugin in DeepSeek Harness, call company_scan for the companies <company-list> with the listed data files. Expect company cards and a list of rejected files with reasons. Verify that each metric has source and asOf, and that unsupported items appear as gaps.

  • Find claims in a draft that lack source evidence

    Seal a draft and read the visible markers to see which claims have no bound evidence.

    View prompt
    Using dsh-research-report in DeepSeek Harness, seal a report on the draft at <draft path> with no evidence bound to the claims. Expected output: report.md with unverified markers on each unsupported claim. Verify that every claim with an empty evidenceIds list is marked unverified rather than passed silently.

  • Serve the three Jev tools to a non-DSH MCP host

    Run the jevcore-mcp stdio server so any MCP host can call the jev_ask, jev_rank, and related tools.

    View prompt
    In the PerryLink/jevcore repo, start the jevcore-mcp stdio server with npx -y jevcore-mcp and register it with <MCP host config file>. Expected output: the host lists the three Jev tools. Verify that the egress report appears on stderr and that nothing else prints to stdout before the host connects.

  • Cut extra copy and rewrite CTAs across several pages

    Click through linked pages in the review tool and trim copy without losing feedback between them.

    View prompt
    Use the petergyang/human-review skill to open <path-to-start-html-file> and review the linked pages. After I click Send, verify that the agent removed the repeated copy and updated each call to action in the HTML files, and list the files changed.

  • Spot unused indexes and likely missing indexes

    Find zero-scan indexes and large tables with heavy sequential scans before dropping or adding anything.

    View prompt
    Use the pgbot tool from the pgrundev/pgbot repository to run `pgbot indexes --json` and `pgbot tables --json` against <target-db-url>. List the zero-scan indexes with their sizes and the large tables with heavy sequential scans. Verify that you do not recommend dropping any index while replication is active without stating the per-node scan caveat.

  • Check a generated world against reference photos

    Run Playwright screenshots of fixed viewpoints and compare them with photos from the same spots.

    View prompt
    Using the repo PhiloLabs/fable51-worlds, run Playwright against the built world and capture screenshots at the fixed viewpoints in its QA report. Expected output: a table of viewpoints with a pass or defect note for each one, compared against reference photos you supply. Verify that each screenshot is taken from the viewpoint the QA report lists.

  • Move a WordPress site into Kaleta

    Import an existing WordPress site into the Kaleta page builder instead of rebuilding it by hand.

    View prompt
    Using the kaletacms repository, help me import the WordPress export at <export-file> into my Kaleta site at <site-url>. Expected output: a list of imported pages and any items that did not import, and verify that each imported page opens in the builder before I publish.

  • Turn your notes or transcript into a human-sounding work piece

    Build a post or memo on your own argument, order and examples instead of an AI draft.

    View prompt
    Use the work-humanizer skill from the phuryn/work-humanizer repo on my notes in <notes-file>. Build the piece on my claims, in my order, with my examples, and ask only about gaps. Output the piece and the fact audit. Verify that each claim in the piece matches a claim in my notes at the same strength.

  • Schedule automatic scans for new postings

    Set a Pro routine that saves new matching postings on Pinloop's servers.

    View prompt
    Using the pinloop-cli repo, read the output of `pinloop guide`, then set up a Pinloop routine that scans for <target role> on <schedule or new-posting trigger>. Expected output: a saved routine ID and a first set of saved postings. Verify that the routine is listed as active and that the saved postings match the search.

  • Chat with your own documents using a local model

    Point the app at a local vLLM endpoint and query a local knowledge base with source references.

    View prompt
    Using the Pinvou/pinvou-agent repo, configure a local vLLM endpoint at http://127.0.0.1:8000/v1, create a knowledge collection from <document-folder>, and ask a question about its contents. Expected output: an answer that cites the source collection and file. Verify that disabling that collection removes it from retrieval.

  • Host a private artifact hub for your product team

    Deploy Artifact Server on a hosting target your team already uses for shared review.

    View prompt
    Using the plannotator/artifact-server deployment guide, pick the target <deployment-target> and list the setup steps it needs. Expected output: a checklist of requirements, origins, and storage choices. Verify that the checklist includes both the trusted application origin and the wildcard content domain.

  • Run regression tests before changing the extension

    Run the Node and browser smoke tests to confirm a baseline before editing Paw Work.

    View prompt
    In the PawWork repo at <repo path>, run `node --test tests/runtime-regression.test.mjs` and then `node tests/browser-smoke.cjs`. Report the pass or fail count for each and list any failing test name. Verify that the Node suite runs without a browser.

  • Refine rules after incidents and keep gates current

    Find rules without gates and stale contracts, then turn lessons from commit history into one PR.

    View prompt
    In the repo at <repo-path>, run `/gap-trap refine`. Return the list of rules without gates, stale contracts, and proposed playbook lessons. Verify that each lesson cites a real commit from `git log`.

  • Inspect Vue Pinia stores and walk routes with an agent

    Let an agent read Pinia store state and open Vue Router routes in a running Vue app.

    View prompt
    Using the medula MCP tools from the medula repo, connect to the running Vue dev server for <app-port>, read the state of the Pinia store named <store-name>, then open the route <route-path>. Expected output: the store state and the route the page now shows. Verify that the page displays the same route the agent reports.

  • Monitor agent sessions and run tests from a phone

    Check agent activity, run commands in a terminal, and preview output on a phone while away from the desk.

    View prompt
    Using the powerfooI/roamgate README, connect to the Roamgate instance at <roamgate URL> and report the status of the agent session named <session name>. Include the latest terminal output and whether tests passed. Verify the status matches what the Herdr session shows before reporting.

  • Chat with a local model on a Windows laptop

    Unpack the Windows build and chat with a local model from a terminal.

    View prompt
    On a Windows x86-64 machine, unpack janas-windows-x86_64.zip into <install-folder>, open a terminal in the janas folder, and run .\janas-chat. Report which models are offered and confirm that a chat prompt appears.

  • Hold risky agent tool calls for review

    Let Jev score tool calls, then have your own policy approve, deny, or send them to a person.

    View prompt
    Using the Promethe-us/awesome-jev README, outline a tool-call gate for <my agent> that uses Jev only as an advisory signal and keeps permission checks in application code. Return the policy steps and one test case per outcome, then verify that no tool runs without your own permission check.

  • Check a citation-shaped answer before you use it

    Use the source-record check to find missing source fields in an AI answer.

    View prompt
    Using the Prysai-LLM-Playbook repository, apply the source-record check in book/communication-clinic-EN.md to the answer <answer>. The expected output is a list of citations with missing source fields and one next check or stop decision. Verify that no source is marked verified unless its fields were actually inspected.

  • Cut Vision HOPE inference time on an NVIDIA GPU

    Turn on fast inference for standalone modules or prepare a full model for faster forward passes.

    View prompt
    Using the VisionHOPE repo (PSRben/VisionHOPE), load visionhope_small.pth from weights/, call prepare_for_inference on it, and time 100 forward passes on random CUDA inputs of shape [1, 3, 224, 224] for <target hardware>. Report the average latency before and after preparation. Verify that the prepared model still returns logits shaped [1, 1000].

  • Add a free AI chat page to a WordPress site

    Install the Ptero plugin and place the mlp_ai_chat shortcode on any page or post.

    View prompt
    Using the Ptero repo (Ptero-ai/Ptero) as the reference, install the Ptero WordPress plugin on <site URL> and add the shortcode [mlp_ai_chat] to the page <page title>. Expected output: the published page displays the full chat interface. Verify that the chat loads on the public page while logged out.

  • Ship one approved feature with a second-agent check

    File a spec-linked item, let a builder claim and submit it, then have a verifier accept or reject the exact commit.

    View prompt
    In the repo <path>, file a Pullboard item linked to approved spec row G1, have a builder agent claim and submit it, then have a separate verifier agent run `pullboard verify <id> accept` or reject with a reason. Report the verdict and the note. Verify that the verifier checked out the exact submitted commit before deciding.

  • Find a hosted MCP server for a specific task

    Use a directory listed under Aggregators to locate a remote server that fits your job.

    View prompt
    Using the repo awesome-remote-mcp-servers, connect the Aggregators entry <directory-url> and search for servers that handle <task>. Expected output: a list of up to five server names with their URLs. Verify each URL appears in the README before recommending it.

  • Get an independent review before committing a change

    Run the separate reviewer on staged work, a branch or a path, and check what it cost.

    View prompt
    Using the repo qiz029/dscode, start DSCODE in <repo path>, run `/review` on the staged changes, and return the findings. Verify that each finding names a file and a concrete problem.

  • Review AI token spend across local clients by day

    Chart token use by day, model and agent over any span, priced at public API rates, and share a recap.

    View prompt
    In the Pulse app from https://github.com/qunqin24/Pulse, open the token spend view for the last 30 days, group results by model, and report the top three models by estimated spend in <currency>. Verify that the figures are labelled as estimates priced at public API rates.

  • Run the figure gallery on your own machine

    Clone the repo and serve the static gallery locally, with no backend or build step.

    View prompt
    Clone https://github.com/qwdwqfwq/topconf-paper-figure-gallery.git, start a static server on port 8000 from the repo folder, and confirm that http://localhost:8000 returns the gallery page. Report the URL and the number of figures shown on the page.

  • Talk to an Agent in the browser with live camera frames

    Use the WebUI to stream microphone audio and bounded camera frames to a visual-capable voice frontend.

    View prompt
    Use the repo QwenAudio/qwen-audio-agent to start the WebUI with a visual-capable Realtime frontend. Report the local WebUI URL and confirm that camera frames are streamed with audio. Verify that the Agent's reply references something visible on camera before reporting success.

  • Code with the Mu desktop app and no terminal

    Install the desktop app, connect a model, and watch the judge decisions in one window.

    View prompt
    Download the mu desktop installer for this operating system from https://github.com/qybaihe/mu/releases/latest, install it, and connect a model with <API key or subscription>. Expected output: the app opens and completes one task. Verify that the Judge tab lists verdicts with their timing.

  • Document a service and fail CI when the docs drift

    Write checkable docs whose claims are anchored to code and re-verified on every build.

    View prompt
    In the repo <repo path>, write a claims-based document for the <service name> service in system.docs.json, run vibeX docs with --check, and report how many claims are verified. Verify that the check exits with code 1 when you change an anchored line in a test copy.

  • Switch between Codex accounts and API-key sign-ins

    Save each Codex sign-in, including separate ChatGPT plans and API keys, and swap them from the menu bar.

    View prompt
    Using the Janus repo at RamitVishwakarma/Janus, explain how to save each Codex sign-in on this Mac, including ChatGPT and API-key accounts, and switch to <target account email or key suffix>. Report the saved Codex accounts with their plan or key suffix. Verify that the live file at ~/.codex/auth.json now belongs to the target account.

  • Give the voice assistant memory, weather and clock

    Run the in-repo openmuse agent so answers know your location, time, weather and past notes.

    View prompt
    In the esp32-thinks repo, start the openmuse agent with ./openmuse/run.sh --funnel after setting UPSTREAM_API_KEY and OPENMUSE_TOKEN in openmuse/.env, then report the public HTTPS URL. Verify the agent responds to a chat request and that memory is written to openmuse/data/memories.json.

  • Turn captured app traffic into an API spec

    Capture HTTP calls from an app, then generate an OpenAPI spec or MCP tools from them.

    View prompt
    Using mitmproxy and Spectral from the Awesome-REA README, analyze the redacted HTTP capture at <capture-file> from <target-app> and produce an OpenAPI 3.1 draft in <output-file>. Note any endpoints that need authentication. Verify two generated endpoints against the live service before reporting success.

  • Plan a walking route through a scanned space

    Ask your assistant for a path through the scanned free space from one point to another.

    View prompt
    Using the openreality MCP tools on the scene <scene id>, plan a path from <start point> to <target point> through the scanned free space and describe it step by step. Verify that the description names the start and target you asked for and notes any uncertainty the tool reports.

  • Update a workflow diagram after the code changes

    Ask the assistant for a refined revision and see what was added, removed or changed.

    View prompt
    In the repo <target-project>, refine the MLView diagram <diagram-file>.mlview.json to reflect my recent edits to <changed-file>. Expect a new revision whose Changes since summary lists the affected steps. Verify that the new revision's changed items all cite lines that exist in the current files.

  • Send a small text file to a teammate's agent

    Attach a schema, config, log, or code file to a message for a specific teammate's session.

    View prompt
    In the reason-machines/reason-network repo, send the text file <path> to <teammate>/<session> with `reason-network send <teammate>/<session> --file <path> "<note>"`. Expected output: a delivered message that names the saved copy under ~/.reason/network/inbox. Verify that the file is plain text, under 256 KB, and not a hidden file before sending.

  • Bake Laya weights into a container image at build time

    Fetch the 1.7 GB ONNX bundle during the image build so containers start without a download.

    View prompt
    In the receptron/laya repo, write a Dockerfile for a Node.js 20 service at <service-dir> that installs @receptron/laya and runs ensureBundle() during the build. Expected output: an image where the first Laya.load() in the container finishes without a network download. Verify by running the container with networking disabled and confirming that the model loads.

  • Decompile and de-obfuscate a suspicious function

    Use the lift and decompile operations to turn a VM dispatcher or opaque predicate chain into readable pseudocode.

    View prompt
    In the Recurse app, open <target path> and select the function at <function address>. Run the lift and decompile operations on it, then summarize what the function does in three sentences. Verify the summary against the disassembly listing.

  • Find the real callers before changing a behavior

    Use the callers flag to see whether production code actually reaches a function.

    View prompt
    Use ripwire on the repo at <path>. Run the --callers flag on <function name> and report every production caller it finds. Verify the result by opening each reported call site.

  • Keep every new video on brand with saved components

    Set a project brand once and save animations as components to reuse in later videos.

    View prompt
    In the Remocn Studio project at <project folder>, create a new video called <video name> that uses the saved project brand and the component named <component name>. Expect a new folder under src/videos with an index.tsx scene. Verify that the colors and fonts in the scene match the brand in brand.md.

  • Run existing TypeSafe Jev API code against localhost

    Change one URL so code written for the TypeSafe API calls a local model instead.

    View prompt
    In the rizzo-flow repo, start the server with `uv run rizzo serve`, then point the existing TypeSafe API client in <path-to-app> at http://127.0.0.1:8017 and run its test suite. Return the failing or passing tests. Verify that each decision response has the same shape the client expects.

  • Test the server front end without a GPU or model

    Run the front end test suite against a fake engine to confirm a build works before any model is loaded.

    View prompt
    In the UnbiasedStrata repo at <repo-path>, run make build and make test and report the final pass or fail count. Confirm the tests ran against the fake engine and not a real model.

  • Capture tasks and personal facts by chatting

    Add tasks and save durable facts from chat, then review them in the app.

    View prompt
    Using the Talorys chat at <pages-dev-url>, ask the assistant to add a task titled <task-title> due <date> and to remember the fact <fact>. Report the task ID and memory entry created. Verify both appear in the Tasks and Memory screens.

  • Separate child work from parent time in an agent trace

    Parse a JSONL agent trace, fix overlapping span timing, and output an HTML timeline and regression report.

    View prompt
    In the repo rohitg00/ai-engineering-from-scratch, run the agent-trace-debugger project with --init into learning-artifacts/agent-trace-debugger, then implement the stages until the --all --strict grader passes. Expected output: an HTML timeline and a JSON regression report for the supplied trace. Verify that per-span token counts are not double counted between parent and child spans.

  • Rehearse arm task files in simulation before the arm

    Test an SO-101 task file in the arm's simulator before it touches real hardware.

    View prompt
    Using the rokbenko/quackd repo, pick a task file from docs/examples/lerobot/, run it against a simulated SO-101 arm registered as <arm-name>, and report whether the run completed. Verify that the same task file is then run against the real arm only after the simulated run succeeds.

  • Measure extraction accuracy with the eval harness

    Score a backend on field F1 and schema-valid rate before you trust it in production.

    View prompt
    In the py-idp repo, run `idp eval` on the labeled set at <path to eval data> using the <backend name> backend. Output the field F1 and schema-valid rate per field. Verify that the report lists every schema field.

  • Track a product price and get alerted on a drop

    Ask Rome to watch a price and message you when it falls below your target.

    View prompt
    Using the rome-os/rome instance at http://localhost:7663, ask Rome to track the price of <product-url> and notify me when it drops below <target-price>. Expected output: a confirmation that the price is being watched and a notification when the threshold is crossed. Verify that a test notification reaches the chosen chat channel.

  • Check and steer your desktop agent from a phone

    Use the token-gated mobile web mirror or an IM bridge to follow and redirect a running session.

    View prompt
    Using the Grok App repo (https://github.com/RongleCat/grok-app), enable the mobile web mirror for a running session in <project-name>. Expected output: a token-gated mobile page that shows the session timeline. Verify that the token is required before any page content loads.

  • Watch agents on several machines from one Think Term sidebar

    Connect remote hosts through Think Term Connect and switch between them in one workspace.

    View prompt
    Using the RoversX/ThinkTerm repo, connect ThinkTerm to the remote host <host name> with ThinkTerm Connect, then list the recognized agents in the Agents panel. Expected output: each agent with its project and work status. Verify that the agent processes still run on the remote host after the desktop client closes.

  • Compare Claude response usage across session files

    Group response IDs from two Claude session files to see repeated usage snapshots, conflicts and missing fields.

    View prompt
    Using the AgentMeasure repo, run `agentmeasure response-audit <first-file.jsonl> <second-file.jsonl> --json responses.json` and summarize the conflicts and missing fields per response ID. Verify that the output does not select a winning snapshot or compute a session total.

  • Add the Ruflo console to Claude Code

    Install Ruflo's core, console and mods plugins into Claude Code and open the cockpit with /ruflo.

    View prompt
    Using the repo ruvnet/ruflo, install the ruflo-core, ruflo-console and ruflo-mods plugins into Claude Code on <target machine>. Expected output: the three plugins listed as installed after /reload-plugins. Verify that /ruflo opens the console before reporting success.

  • Keep one character consistent across several clips

    Generate a character reference sheet prompt and reuse the same description in every clip.

    View prompt
    Using the character-sheet-lite skill from the repo Rylaispirit/cinematic-video-prompt-skill, write an image prompt for a character named <character description> showing three full-body views and one close-up in a single image. Return the prompt and the reusable character description block. Verify the character description is identical in the sheet prompt and in a sample clip prompt.

  • See which AI engines send traffic and which pages they cite

    Report ChatGPT, Perplexity, Claude and Gemini referrals from GA4 and the pages they cite.

    View prompt
    Using the open-seo-mcp-skills ai-visibility skill through the Ryze MCP, report which AI engines (ChatGPT, Perplexity, Claude, Gemini) send traffic to <target-domain> and which pages they cite. Return a table of engines, sessions and cited pages from GA4. Verify that the figures come from GA4 AI-referral reports and not from prompt-sampling estimates.

  • Switch between AI providers and models during a long engagement

    Enable, test, and swap model providers from Settings without leaving the workspace.

    View prompt
    Using the repo https://github.com/S1N6H/pentest-harness, start the Web UI with `pnpm dsh web` and add the provider at <base_url> under Settings, then Models. Confirm the live connection test passes and the models auto-discover. Report the provider name and the number of discovered models.

  • Create and test an R15 character animation with AI

    Ask for a run, wave, or dance and the agent makes, checks, and playtests an R15 animation.

    View prompt
    Using the Roqer repo at <repo path>, ask the Roqer agent to create a <animation name> R15 animation for the place <place name>. Expected output: a published animation applied to player characters and a playtest check that it plays. Verify the motion in the 3D preview before accepting the result.

  • Get step-by-step help on anything on your screen

    Point at part of the screen, ask a question, and Atticus draws the steps over what you see.

    View prompt
    Using the repo SaarthurR/atticus-mac, mark a spot on the screen with Point at your screen and ask "<your question>". Expected output: Atticus draws the steps over the screen, one at a time. Verify that the first mark sits on the control named in the question.

  • Build a search index for Senate rules and acts

    Extract, chunk, and embed a folder of Senate PDFs into a FAISS index using the repo's pipeline commands.

    View prompt
    In the cloned salikhussain71-code/PAKGOV-RAG-project repo, place the PDFs from <folder of Senate PDFs> in data/raw/senate/ and run the extract, chunk, and embed commands from the README in order. Report the number of chunks saved and the number of FAISS vectors saved. Verify that scanned PDFs that produced placeholder text are listed, since OCR is pending for them.

  • Vet an ecosystem plugin before you install it

    Check an Awesome resource's source, permissions, and rollback path before installing it.

    View prompt
    Using the sandbaseai/deepseek-harness-handbook Awesome resource map, review the entry named <resource name>. Follow its source link and report the permissions, credentials, and rollback path it requires. Output a go or no-go recommendation and one permission you would refuse to grant.

  • Delegate a repo-wide rename to GPT-5

    Hand mechanical edits across many files to Codex, then review the diff in Claude.

    View prompt
    In the Sateezg/codex-bridge plugin setup, use codex-implementer to rename <old-name> to <new-name> across <repo-path>. Report the list of changed files. Verify with a diff that only the intended identifiers changed before reporting success.

  • Tile windows or repeat a task in every window

    Give one command that arranges windows or runs the same steps in each open window.

    View prompt
    Using jev-use on this Mac, run `scripts/say.sh "<command>"` where <command> is a window task for the app <app>, such as tiling its windows. Expect the windows to be arranged or the task repeated in each window, with the result reported as DONE, BLOCKED or WAIT. Verify by checking every window on screen and reading the log with `log show --predicate 'subsystem == "local.jev-use"' --last 10m --info`.

  • Build a custom environment with the SDK

    Add the SDK to a Python project and build an environment server for your tasks.

    View prompt
    In <project folder>, add agentenv-framework with `uv add agentenv-framework`, then follow the environment server SDK section in packages/agentenv-protocol/README.md of scaleapi/agentenv-framework to create a minimal environment server. Report the files you created and the commands you ran. Verify that `python -c "import agent_env"` runs without error inside the project environment.

  • Watch every saved server's health on one page

    See online status, CPU, memory, disks, and load for all saved hosts without installing anything on them.

    View prompt
    In the scarletkc/Hatoba app, open the Dashboard after importing hosts from ~/.ssh/config, then list each saved host with its online status and CPU and memory readings. Verify that every saved host appears once and that no software was installed on the servers.

  • Gate doc changes with Seiso in Claude Code hooks or CI

    Run Seiso automatically when an agent or a commit changes project docs.

    View prompt
    In the repository at <repo path>, configure a Claude Code hook that runs `seiso check` after doc edits, following the integrations guide. Report the hook configuration you added and the result of one test run. Verify that the gate runs only stable rules.

  • Follow subagents as cards or swimlanes

    See each subagent's task, live context, output tokens, steps and clock, and expand any one for detail.

    View prompt
    Install the scasella/claude-flightdeck plugin in Claude Code 2.1.287 or later, start a task that spawns at least two subagents, and open /flightdeck. Report how many agents appear as cards or swimlanes and flag any agent showing max_tokens in red. Verify the expanded view of one agent shows its last three tool calls.

  • Turn a written scene description into a greybox layout

    Use Blockout to build a rough blocked-out set from a text description.

    View prompt
    Using the scenario-labs/blender-plugin Blockout feature in Blender 5.0 or later, turn this scene description into a greybox layout: <scene description>. Report the number of objects created and the CU estimate. Verify that the layout appears in the scene and can be rebuilt from Blockout.

  • Shoot product packshots and scenes from a real photo

    Turn one real product photo into packshots and lifestyle scenes with label checks.

    View prompt
    Using the scenario-labs/skills repo, create packshots and lifestyle scenes from the product photo <photo-path> for the scenes in <scene-list>. Save approved images to <output-folder>. Verify that the label text in each approved image matches the original photo.

  • Get live summaries and minutes from your background agent

    Let MeetCap run your existing agent in the background to catch you up mid-meeting and write minutes after.

    View prompt
    Using the seacen/meetcap repository, configure MeetCap to run <agent name> in the background and record the meeting <meeting name>. Expected output: a live summary during the meeting and minutes when it ends. Verify that the minutes open with the reason for the meeting and that each point links to a transcript line.

  • Route Claude Code and Cursor traffic through the gateway

    Send coding agent model calls through AI-FW so prompts are inspected and governed.

    View prompt
    In the securetron-gh/aifw repo, follow docs/tutorials/02-claude-code-cursor-mcp.mdx to point <agent-name> at the running gateway. Report whether one test prompt appears in the dashboard, and verify the agent still gets a response.

  • Diff the official Breeze code against the vLLM-Omni patch

    Compare the reference inference code with the modified framework source to see exactly what changed.

    View prompt
    In the repo Sentinel3252/Native-Breeze-TTS-2-Support-for-vLLM-Omni, use project-manifest.json and the files under breeze-tts/ and vllm-omni/ to list each integration file and the reference file it corresponds to. Report any file you cannot match, and do not infer changes the repo does not document.

  • Check whether a Divar ad is fairly priced

    Have an agent compare a home, car or phone ad on Divar with the market and flag bad deals.

    View prompt
    Using the awesome-iran-mcp divar server, check whether the ad at <ad link or search term> in <city> is fairly priced compared with similar listings. Return the fair-price result, the market statistics behind it, and the three best-value ads with prices in Toman. Verify that each price comes from a tool result.

  • Fix a loud moment or score an existing film

    Ask Claude Code to add a score or fix a timed loud passage in a riso film, checked with loudness sheets.

    View prompt
    In the riso-windowseat repo, use the riso-score skill to fix <timestamp and issue> in films/<film-name>/ or to add a score to it. Expect an updated index.html and loudness sheets from tools/. Verify the named moment is quieter or scored and that AUDIO-SOURCES.md lists every audio source used.

  • Build the desktop app from source and run native checks

    Compile the Tauri desktop app and run the Rust and frontend checks listed in the README.

    View prompt
    In the repository sevensir888/codex-command-center, run the native checks listed in its README and report the result of each as pass or fail. Output a table with one row per command. Verify that `npm run check:secrets` reports no tracked-file secrets before any commit.

  • Add a prose contract to AGENTS.md and Cursor rules

    Write the Sloptrim contract into a project so Codex or Cursor agents follow it.

    View prompt
    In the project at <project path>, run `/sloptrim init` and report which files were written. Verify that AGENTS.md exists and that a Cursor rule exists under .cursor/rules/.

  • Rewrite a report while keeping chosen quotes word for word

    Import a Word or PDF report and mark the passages that must stay exactly as written.

    View prompt
    Using the sgaofen/humanizer-local-model repo app, import <path-to-report.docx> and mark the passages listed in <passages.txt> with Create fact before rewriting. Expected output: a rewritten report in which each marked passage appears word for word. Verify that each marked passage is highlighted in the rewrite and matches the original exactly.

  • Make coding agents fix Lint errors before finishing

    Give the agent a Lint command and an instruction to run it and fix errors after every change.

    View prompt
    Use the GitHub repo shadcn-ui/lint to set up the lint loop in <project-path>. Install the package, add the lint script, and add the README instruction to AGENTS.md. Expected output: npm run lint exits cleanly on the current code. Verify that a deliberate arbitrary value in one file makes the command report an error.

  • Keep designed Shaders in sync with your codebase

    Use the Shaders CLI to link a project, install designs as files, and pull later edits.

    View prompt
    In the shader-effects-inc/shaders repo, use the Shaders CLI to connect <project-path> to a Shaders project, install <shader-name>, and update it. Expected output: the new component files and an updated lock file. Verify that the lock file lists the installed shader.

  • Set spending limits so one team cannot run up the AI bill

    Use tenant keys with budgets, rate limits, and per-request ceilings to control AI costs.

    View prompt
    In the ShadowSafin/Synapass repo, create a tenant named <team_name> with a daily budget and a rate limit through the dashboard or admin API, then mint one key for it. Report the tenant id and confirm that a request above the configured ceiling is refused. Verify the refusal in the response before reporting success.

  • Run the 4B decision model on a Mac

    Serve the MLX build of v6.1-VL 4B on Apple silicon using the MLX backend.

    View prompt
    In the Shanghua-Gao/RSI-Jev repo, install the mlx extras with pip, then run `rsi-jev serve v6.1-vl-4b-mlx-8bit --backend mlx`. Follow docs/mac.md and send one decision request about <question> to the local server. Return the answer and the layer reported. Verify that the server runs on Apple silicon and returns a response without errors.

  • Have an agent order from your iPhone via Mac mirroring

    Let an agent drive your iPhone through the Mac's iPhone Mirroring window to finish an app errand.

    View prompt
    Using the phone-harness repo at https://github.com/ShawnPana/phone-harness, use the iPhone Mirroring window on this Mac to complete the errand <errand description>. Stop before the final payment confirmation and report the screen text, then verify the order details match the request before approving the last step.

  • Build and run the game from source on your computer

    Install dependencies, build, and start the local server from the repository.

    View prompt
    In the cloned Infinite Pokémon repository, run npm install, npm run build, and npm start, then confirm that http://127.0.0.1:8788 responds. Report the build result and any Node SQLite experimental warning that appears.

  • Query semantic conditions directly from psql with native functions

    Call jev_native functions from any PostgreSQL client against tables you already own.

    View prompt
    Use the jev4pg repository to install the jev_native extension on a PostgreSQL 17 server and grant access to a SQL login named <login> for the table <schema>.<table>. Return a grouped query over jev_native.scan and confirm that the result includes decision states and uncertainty for each row.

  • Track local project tasks in a native Web UI board

    Create projects and tasks in the Harness Web UI and keep them in a local SQLite file.

    View prompt
    Using the DSH-taskboard README at https://github.com/shengsheng90/DSH-taskboard, create a project named <project-name> and a task titled <task-title> in the Harness Web UI. Report the task key and status, and confirm both persist after a page refresh.

  • Try an avatar in the browser without installing anything

    Open the Player in Chrome or Edge and move the sample or your own .mavatar file with your face.

    View prompt
    Open the Mesh Avatar Studio Player in Chrome or Edge and load the bundled sample. Expect the avatar to animate in the page. Verify that blinking and talking appear when the webcam and microphone are on.

  • Score, dedupe, and report findings for a write-up

    Turn a raw findings list into a deduplicated, CVSS-scored report with an integrity hash.

    View prompt
    Using the blitzstrike MCP server, call dedup_findings on <findings list>, then cvss_score for each group, then generate_report in <markdown or json>. Return the report with a summary and the SHA-256 integrity hash. Verify that every group has a CVSS base score and severity.

  • Estimate print time and filament cost before printing

    Use Nurb slice to get minutes and grams from your installed slicer before a design is final.

    View prompt
    Using the nurb repo (Shpigford/nurb), run `nurb slice` on <target part name> and report print time in minutes and filament in grams. Verify that a slicer was found, since the README says nurb drives an installed OrcaSlicer or Bambu Studio.

  • Run Gideon in one Docker container with persistent state

    Build the single-container image from the checkout and run it with a persistent volume.

    View prompt
    In the Sidiora-Labs/centra-gideon-agent checkout, build the image with the README Docker command and run the container named gideon. Report the access URL from docker logs gideon. Verify that the container is running with docker ps before you report success.

  • Fan a task wave out to parallel Codex or Claude Code sessions

    Claim conflict-free tasks and run each in its own sandboxed agent process.

    View prompt
    In the Hyperfide repository, run `hyperfide spec run` for wave <wave number> using Codex CLI or Claude Code. Report each claimed task, its log location, and its final status. Verify that no two tasks declare overlapping paths before the run starts.

  • Connect a wallet or app to the Paxeer X chain

    Point a wallet or app at chain ID 125 using a public JSON-RPC name from the reference list.

    View prompt
    In the Sidiora-Labs/Paxeer-X-Network repo, read docs/site/docs/reference/public-rpc.md and select one public JSON-RPC name for chain ID 125. Report the endpoint name and the first two RPC methods listed in docs/wiki/PublicRpc.md. Verify that the chain ID you report is 125.

  • Adapt Free My TV to a different TV brand with an AI agent

    Have an AI agent read a non-listed TV, update the app's debloat and shelf lists, and walk through a test.

    View prompt
    In the free-my-tv repo, read CLAUDE.md and update the DEBLOAT, PROTECTED, SHELF and LIVE_TV_APPS lists for the TV brand <BRAND> at <TV_IP>. Expected output: edited lists in HomeMode.java and HomeApps.java and a built FreeMyTV.apk. Verify that no picture, sound, input, remote, Google service or Play Store package appears in DEBLOAT.

  • Get an agent officially scored on the 60 tasks

    Run an agent under the official protocol through the Simreal evaluation service.

    View prompt
    Read AGENT_GUIDE.md and docs/GATEWAY.md in the Simreal-MLBench repository. Summarize how an agent calls the mleb-remote SDK, the tier budgets, and the two-submission rule for <target agent>. Expected output: a short integration checklist. Verify that the checklist names the business contact before any run is planned.

  • Restore the last working config after a bad gateway change

    Bring back the most recent backup of Claude Code, OpenCode, or Codex config with one command.

    View prompt
    In the repo Sinholms/setup-gateway, run `node setup-gateway.mjs restore <TOOL>` where <TOOL> is claude, opencode, or codex, adding --yes for the newest backup. Expect a message that the config was restored and that a backup of the previous state was made first. Verify by running `node setup-gateway.mjs status` and confirming the values match the backup.

  • Have an agent render an explainer from a command

    Let a coding agent run the Frametell CLI to produce a narrated MP4 from a source file.

    View prompt
    Use the Frametell repo at sitor-ai/frametell, after pnpm install and pnpm build. Run node apps/cli/dist/cli.js run <file> --style <style> --duration <seconds> --lang <lang> and report the path to the rendered 1080p MP4. Verify that subtitles are present and that the film matches the approved storyboard.

  • Create a Codex pet with no OpenAI API key

    Generate a companion through local open-weight editing and avoid hosted image APIs entirely.

    View prompt
    Using the repo six-nut/PocketMen-with-you, run `pocketmen create` with --engine neural --backend flux2-klein-4b on the references at <photo-1> and <photo-2>. Expected output: pet.json and spritesheet.webp, with no OPENAI_API_KEY set. Verify that the final package contains only pet.json and spritesheet.webp.

  • Try the offline demo with no account or model calls

    Run the bundled demo to see extraction and validation without AI generation.

    View prompt
    In the knowledge-base-kit repo, run `python scripts/offline_demo.py ../kb-demo`. Confirm that the demo workspace was created and that validation passed. Report the paths of examples/expected-output/quickstart/full.md and summary.md for comparison, and state that the demo does not simulate AI generation.

  • Read a one-page brief when you come back to the desk

    Get one page of what got done, what is stuck, and what waits for your answer.

    View prompt
    In the repo <repo-path>, produce an away brief with the away brief skill from Sno Station Skills covering the last <time-window> of agent activity. Output at most 60 lines with done, stuck, waiting-for-you and quota-cost sections. Verify that every stuck item names a reason.

  • Review the skill changes Self Learning proposes each morning

    Read the nightly proposals and accept only the ones you want applied to your agents' skills.

    View prompt
    In the sno-station repository, review the proposals from the last Self Learning run and accept only the ones I approve using `sno rem-reflect accept`. Expected output: a list of accepted and rejected proposals. Verify that no skill changed for a proposal you did not accept.

  • Capture a TikTok video with its media as evidence

    Read a selected TikTok video and save its media offline when your goal explicitly asks for it.

    View prompt
    Use the socai-io/jev-social repo to read the TikTok video at <url> and save an offline copy of its media, since the goal explicitly requests it. Expected output: metadata, an MP4, and a poster in the socai evidence store. Verify that the media download appears in the operation history and note any missing comments.

  • Map project structure and component progress from PLAN.md

    Use Agenttrail Map to see which components are changing, with progress from a PLAN.md file.

    View prompt
    In the repo <repo-path>, run `npx agenttrail init`, review the setup, and create a starter PLAN.md that uses stable {#id} component values. Report the list of files the setup wrote. Verify that the Map shows each component with its status marker ([~], [x] or [!]) after running `npx agenttrail`.

  • Confine a coding agent to one project folder on Linux

    Start an agent in a closed box where only one project directory exists and nothing else on the machine is visible.

    View prompt
    On a Linux machine with bwrap installed, use the SolonGate repo at https://github.com/solongate/agent-security to create a sandbox box from the TUI Sandbox section for <project-path>, then run `solongate sandbox 001 claude`. Expected output: the agent starts with the project at /workspace and home directories absent. Verify by running `solongate sandbox --explain 001` and checking that the listed contents match the project only.

  • Monitor a server fleet with the MaidCafe daemon

    Sign in to MaidCafe Cloud and let Maid Kit install an outbound-only daemon that streams live host metrics.

    View prompt
    Using the Solsynth/MaidKit app, sign in with a Solarpass account, select a workspace, and run the one-flow daemon setup for <server-address>. Expected output: the daemon appears in the Fleet view with live metrics. Verify that the daemon still reports after MaidKit is closed, since it runs on its own.

  • Scope a firmware or driver fix from a documented case

    Adapt a published exact-build patch or driver fix to your own device after checking its limits.

    View prompt
    Using the songshikang0111/awesome-REA-cases repo, open the case for <device and problem>. List the exact build, hardware, and test conditions it reports, then compare them with my device build <build number>. Output a go or no-go decision with reasons, and state which claims the README marks as not independently reproduced.

  • Expose Jarvis home and PC tools to an MCP client

    Start the MCP server so an MCP client such as Claude Desktop can use Jarvis home and PC tools.

    View prompt
    In the sosoj92/jarvis-assistant-vocal repo, find the MCP server start command and register it with <MCP client name>. Expected output: the client lists the Jarvis home and PC tools and one read-only call returns a result. Verify the tool list before reporting success.

  • Prepare a development machine for agent-driven work

    Install and record the tools, agents, and integrations needed before starting projects.

    View prompt
    Read the repo soumatheusgomes/vibe-coding-toolkit at docs/prompts/10-development-environment-setup.md and execute the entire Prompt section on this computer. Report installed versions, backups made, validations passed, and any required manual steps. Verify that the manifest of versions and scopes was written.

  • Control your agents from your phone with Telegram

    Pair Telegram by QR code, message your agents from anywhere and open a live desktop link on your phone.

    View prompt
    Using the open-source repo SouravBeraAkaSpeed/xiryn, pair Telegram with a local Xiryn install and send <request> to an agent from the paired bot. Expected output: the agent's reply and a progress update in Telegram. Verify that the agent answers when the browser tab is closed.

  • Compare options against a codebase before deciding

    Ask Hermes Agent to compare candidate approaches against your code and recommend one.

    View prompt
    Using the Spielewoy/autoprompt-skill repo, run `autoprompt activate hermes --target <absolute project path> -- "compare <option A> and <option B> against this codebase and recommend one"`. Expected output: a comparison of the options against the code and one recommendation. Verify that each claim points to a real file or function in the project.

  • Build a two-character fight scene from one video

    Split a two-performer plate into two Mixamo characters and check reach and collisions.

    View prompt
    In the squall01337/mixamo-llm-mocap repo, estimate both performers from the plate at <video path> with --person left and --person right, then run setup_duo.py and compare_pair.py. Expected output: one scene with both characters and a pair report on separation, reach and intrusion. Verify the pair report lists the frames where the fighters come closest and that no intrusion values are missing.

  • Check whether two papers agree on a specific claim

    Select two library PDFs, turn on Compare, and see which retrieved passage pairs support or contradict a claim.

    View prompt
    Use the Sreehari05055/thesys-core repo with a valid TYPESAFE_API_KEY to compare the two library papers <paper A> and <paper B> on the claim <claim text>. Output the list of passage pairs with their labels and confidence values. Verify that each pair shows the matching passages in both PDFs.

  • Watch Claude Code session state on a desktop pet

    See on the desktop when Claude Code is thinking, running tools, failing, compacting, or finished.

    View prompt
    In the clawd-conduit repo, run `lsof -nP -iTCP:23333 -sTCP:LISTEN` after `bash install.sh` and report whether Clawd on Desk is listening. Then count the events wired by the python3 check in the README and confirm the result is 15 events.

  • Build the Starling Terminal from source

    Compile the Starling Terminal app with Swift for local use or to modify it.

    View prompt
    In the starling repo, run cd apps/TerminalApp && swift build -c release. Expected output: a release build of Starling Terminal with no errors. Verify that the build finishes and that the Terminal sources match the features listed in the README, then report the result.

  • Send decisions with no fitting option to a person

    Use none_probability to route questions where no listed option seems right.

    View prompt
    Using the StartLux-Decision repo, send <question_text> with the listed <criteria> to POST /v1/systemone with none_check set to true. Return the choice, its confidence and none_probability. Verify that any answer with none_probability of 0.2 or more is marked for human review.

  • Hand off a stuck task to another agent

    Pass a session's task, diff and failed commands to a new Claude Code or Codex session.

    View prompt
    Using the Tellurion repo at https://github.com/steventsvik/Tellurion, hand off the Claude Code session in <project-folder> to a new Codex session with the Review action. Report the diff size included in the handoff. Verify that the handoff message lists the failed commands from the first session.

  • Send a research set to a notes or file MCP tool

    Hand a Knowledge Project to a compatible notes or file tool through the review-first path.

    View prompt
    Using the Superpower repo at https://github.com/stloendays/Superpower, hand the Knowledge Project <project name> to the connected notes MCP tool <tool name> through the review-first path. Expected output: a confirmed write in the destination with a result message in the chat. Verify that the destination item contains each source URL from the Project.

  • Audit every policy decision an agent made

    Read the OTLP JSON decision records to see what Box allowed and denied during a run.

    View prompt
    In the strands-agents/box repository, run the box with a policy.dw that forbids outbound requests to <host>, then open /private/telemetry/records.jsonl. Expected output: a JSON Lines record showing the denied request to <host>. Verify that a request to an allowed host appears as permitted.

  • Serve a scorer that other services can call

    Run the decision model as a local HTTP server and send it questions with curl.

    View prompt
    Using the strands-decider repo, start the server with the 2B model on port 8000, then POST a state of <text> and a score question to /v1/systemone. Return the score and confidence from the JSON response. Verify that the response contains an answers object and a latency_ms field.

  • Build a character intro reel from your own assets

    Combine your image and voice file into a beat-synced HyperFrames intro with a generated score.

    View prompt
    In the hyperframes-motion-reel-skill repo, run /hyperframes-motion-reel with <image path> and <voice path> and the text 'character intro reel'. Expected output: an MP4 intro whose length follows the voice file and whose audio includes the generated score. Verify that the final duration matches the voice length, rounded to the beat grid.

  • Load a bf16 model in Python with Glyd

    Use glyd.from_pretrained to load Qwen3.5-9B from a Python script.

    View prompt
    In the repo surya-koritala/Glyd, install the package with `pip install "glyd[vllm]"` and run `import glyd` followed by `model = glyd.from_pretrained("Qwen/Qwen3.5-9B")` on a machine with <GPU model>. Report any errors and the GPU memory in use after loading. Verify that the model object is created without an exception.

  • Search and filter every scored job in a local web page

    Open a local web UI at localhost:8765 to search and filter all tracked openings and their scores.

    View prompt
    In the jobradar repo, run ./run.sh scan and then start the UI with ./run-web.sh. Report the local address and how many jobs appear in the web UI. Verify that http://localhost:8765 loads and shows scored openings.

  • Recover when an SMS code does not arrive

    Ask for another SMS or cancel for a refund when a code never lands.

    View prompt
    Using the sv-number/mcp-server tools, check the activation <activationId> with wait_for_code, then call request_another_sms once if no code arrived, and cancel_activation if it still fails. Expected output: either a parsed code or a cancellation result with the balance from get_balance. Verify that the cancellation result is returned before you report the money as refunded.

  • Install the SyncSo skill into coding agents

    Use npx skills add to load the SyncSo skill into Claude Code, Codex or Cursor in one command.

    View prompt
    Install the SyncSo skill from SyncSo-Inc/syncso into this project with npx skills add SyncSo-Inc/syncso. Then ask the installed agent for three live events in New York this weekend. Verify that the result includes times, prices and booking links, and that the skill was loaded from the repo.

  • Share the GPU between llama-swap and ComfyUI without ping-pong

    Put llama-swap's models and ComfyUI under one lease so a model swap waits for the image job.

    View prompt
    In the Berth repo at <path to berth>, run `berth wire llama-swap` against the llama-swap config at <config path>. Expected output: each model entry is wrapped in `berth run`. Verify with `berth status` that a ComfyUI job and a llama-swap model are queued in turn rather than loading together.

  • Turn agent results into shared online documents and sheets

    Have agents write into Tab Tin documents, sheets, and slides so people edit the same result.

    View prompt
    Read the README at <repo-path>/README.md, section 人和 Agent 操作同一份结果, and list the collaboration apps it names. Report which apps are named and flag any app mentioned in your own notes that the README does not name.

  • Check thermal stress in a heated steel bracket

    Run the heated-bracket sample to see steady heat flow and the stress it causes.

    View prompt
    Using the FieldCraft repo at tangency-labs/fieldcraft, run the heated-bracket sample with `fieldcraft --sample heated-bracket` and solve it. Report the peak temperature and peak thermal stress, and verify the stress results against the reference described in docs/examples.md before reporting.

  • Summarize a long live-stream video by timestamp

    Produce a timestamped summary of a long stream video, using TLive Omni's grid layout and 256K context.

    View prompt
    Using the TLive-Omni repo at https://github.com/TaoLiveAIGC/TLive-Omni, create a timestamped summary of the live-stream video at <path to video>, listing time, what happens, and any product mentioned. Verify that three timestamps match the source video before reporting.

  • Add a local model server beside the free tiers

    Register llama.cpp, LM Studio, vLLM, or Ollama as a custom provider in the same router.

    View prompt
    In the freellmapi repo (tashfeenahmed/freellmapi), add a custom OpenAI-compatible provider pointing at <local-server-url> on the Keys page and route one chat request to it. Expected output: a completion generated by the local model. Verify that the router logs the request under the custom provider and not a cloud provider.

  • Share AI analysis with company colleagues

    Install Enterprise Connection to send analysis text and files to colleagues with @ mentions.

    View prompt
    Using the WorkDSH repo at techflag/workdsh, install the Enterprise Connection plugin and sign in with the company account <company address>. Expected output: a share of analysis text and files to <colleague name>. Verify that the share appears under sent items in Collaboration and under received items for the colleague.

  • Preview a local Vite or Express server on your phone

    Run a Vite, Next.js, or Express server on the phone and test it in a sandboxed WebView.

    View prompt
    In Mobile Harness on an ARM64 Android phone, start a Vite dev server for the project at <project-name> from the Terminal and open the Instant Web Preview. Expected output: the app renders in the WebView with console messages visible. Verify that the page loads without errors in the console.

  • Build a typography-only brand sting

    Turn a logo and one idea into a short kinetic-type sting with measured motion and no photos.

    View prompt
    Use the motionmaxxing skill from Tejashmakwana/motionmaxxing to build a typography and vector brand sting for <brand name or site>, with one central idea and no photos of people. Output final.mp4 and a NOTE.md. Verify that the lint reports no page chrome before you deliver.

  • Replace or remove words in an existing recording

    Change what is said in a recording by describing the edit in the instruction, keeping the voice and rest of the audio.

    View prompt
    Using the Tencent-Hunyuan/AuK repo, run auk-infer on <input.wav> with an instruction that replaces <old words> with <new words>, and write the result to <out.wav>. Verify by listening for the new words and checking that <out.wav> exists with a length close to <seconds>.

  • Let an IDE or terminal AI drive your agent over ACP

    Expose your agent through the stdio ACP server so an external coding AI can invoke it.

    View prompt
    In the TencentCloud/octop-harness repo, find the ACP stdio server start command in the docs and start it for the agent <agent name>. Connect the client <client name> and send the request <request>. Verify the client receives a reply from the agent.

  • Adjust sprite bounds and object properties by hand

    Use the web Dashboard to preview animations and tweak character settings without writing code.

    View prompt
    Using the VibeGame repo at https://github.com/tettethu/VibeGame, start a project with vibegame start and open the VibeGame Dashboard. Expected output is updated sprite bounds and object properties for <character name> in the Assets and Objects tabs. Verify by opening the Play tab and confirming the character's animation and size changed.

  • Give Codex threads in T3 Code shared project memory

    Run the T3 Code installer so Codex and Claude Code providers in T3 Code get Claude Mem memory.

    View prompt
    Run `npx claude-mem install --ide t3code` on this machine, then restart T3 Code and start a new Codex thread in <project path>. Report which providers the installer discovered and whether the new thread shows prior context. Verify the installer output lists the Codex provider.

  • Schedule a daily storage check and agent standup

    Set up recurring routines so agents run a storage check and hold a daily standup.

    View prompt
    Using the repo theNetworkChuck/paperclip-guide, set up the daily storage check and daily agent standup routines from prompts/routines/ in a Paperclip company on <target machine>. Report each routine's schedule and the output of one manual run. Verify that the standup output includes questions the agents sent to each other.

  • Move a Lightroom Classic catalog into Rembrandt

    Bring edits, keywords and collections from Lightroom Classic into a free editor.

    View prompt
    Using the repo thesnarkitecht/rembrandt, run a Lightroom Classic catalog import into Rembrandt for the catalog at <catalog-path>. Report the count of imported edits, keywords and collections, and list every item in the import report that did not come over.

  • Build interactive money tools, such as a loan or bill-split calculator

    Use the working-tool pattern with sliders, @Payment and @Allocate to build a calculator answer.

    View prompt
    In thesysdev/open-intelligent-ui, read the function list in src/lib/functions/ and confirm @Payment and @Allocate exist. Then send the request "Make a loan calculator with sliders for amount and rate" to the running chat and report which functions and Slider components the generated OpenUI Lang uses.

  • Generate model prompts from a component list on the server

    Use the framework-agnostic core to build system prompts on a backend or Edge function.

    View prompt
    Using the thesysdev/openui repo, add @openuidev/lang-core to the backend at <target backend path> and generate a system prompt from a component library that has at least two components. Expected output is the prompt text; verify that it lists only the components you defined.

  • Compare Jev and a chat model on the same agent

    Run one Blackjack agent with Jev and with the chat model, then compare score and time.

    View prompt
    In the system1-agents repo, run the blackjack agent with --model jev and then with --model llm, both with --episodes 20 and --rethink off. Report the score and wall-clock time of each job folder. Verify that both runs completed 20 episodes before comparing them.

  • Pick the car's model by its measured speed on the Pi

    Compare each model's measured speed on the Pi, then swap the running model from your phone.

    View prompt
    Using the CarWatch repo at https://github.com/ThinkOffApp/CarWatch on <pi-host>, call GET /api/models and list each model with its size and measured generation speed, then name the running model. Verify that each reported size matches the size of its .gguf file on disk.

  • Cut off dangerous tool calls from a relay before the client runs them

    Stop answers that download code, read credentials or add startup items before Claude Code or Codex executes them.

    View prompt
    Using the repo ThinkWatchProject/ThinkWatch-Lite, enable the Dangerous commands protection for the upstream <upstream name> and report which rules are in Monitor mode and which are enforcing. Expected output: a list of rules with their action. Verify that a test answer containing a flagged tool call is recorded in the request history.

  • Scan a paper folder for AI-style surface traces

    Run slop_lint.py for counts of 28 surface traces, each with a file, line, and snippet.

    View prompt
    In the absent-author repo, run tools/slop_lint.py on <paper folder> with --source and write the output to lint.md. Summarize the checks in the high band and list their file, line, and snippet. Verify by reading two of the cited lines yourself.

  • Install the Jev Harness skill in Codex

    Add the jev-harness skill to Codex and use it to plan a harness for your task.

    View prompt
    In Codex, install the jev-harness skill from https://github.com/TianyuCodings/JevHarness and then run it on the task: route <ticket type> to the right team. Expected output: a list of clarified inputs, legal actions, examples, and success criteria. Verify that the skill is discovered before the task is sent.

  • Correct a stale memory without losing its history

    Update or replace a wrong memory while keeping the old version for lookup.

    View prompt
    Use the agent-memory repo at <store path> to correct the memory at <memory path> so it reflects <new fact>, keeping the old version for as-of recall. Expected output: the new memory path and the superseded status of the old one. Verify that a normal recall returns only the new version.

  • Audit a site before launch, regardless of its framework

    Test a React, Vue, Next, WordPress, or static site with the same checks before it goes live.

    View prompt
    Using the tigerless-labs/seo-ops skill, check <target-url> and save the pass/fail report as a baseline. After the migration, check the new URL with the same skill and list every check whose result changed. Verify that both reports cover the same 26 checks before comparing them.

  • Get a daily card of the mail worth reading

    Turn your Gmail inbox into one read-only card in your feed every morning.

    View prompt
    In the TimeLovercc/mojito repo, enable the daily 'mail worth reading' feed card using a read-only Gmail connection on <hub-url>. Expected output: one feed card for the day with a short list of messages. Verify that no message was sent, archived or deleted.

  • Run a quantized NeoHorse-1 on your own hardware

    Download a GGUF or MLX build of NeoHorse-1 that uses less memory than BF16 weights.

    View prompt
    In the TokenRhythm/NeoHorse repo, find the GGUF build of NeoHorse-1-4B on Hugging Face at <model-page> and pick the 4-bit quantized file. Follow that model card's deployment instructions and return the model's reply to the prompt <test-prompt>. Verify that the file size of the chosen build is smaller than the 16-bit BF16 build.

  • Ask the agent to inspect a web page beside your code

    Have Eido's agent check how a page behaves while you work on the code behind it.

    View prompt
    Using the Eido repo (tony3liu/eido), open the project at <project-folder> and ask the agent to inspect the page at <page-url> using Browser Use, then report the visible problem and the code that produces it. Expected output: a short written report and any proposed code changes in the review interface. Verify that the page the agent inspected is the one you named.

  • Check how many Tokens a multi-agent run used

    Read per-run Token buckets and coverage status in Run Center for planner, member, review, and repair usage.

    View prompt
    Using the dsh-agent-team-gui repo, open the Team runs entry for <run-id> and extract the planner, member, review, and repair Token counts with their coverage status. Report a table of the four buckets per step. Verify that any run showing Metering… is reported as pending, not as zero.

  • Dictate in English and insert Spanish text by holding right ⌘

    Speak in one language and insert the translation on-device with one shortcut.

    View prompt
    In the repo tornikegomareli/Talkify, find the Speak one language, insert another section and summarize how the right ⌘ key chooses the target language. Verify and state whether the README says translation runs on the Mac.

  • Keep a long task on track across fresh chats

    Use Goal, Loop and Compact & Resume to keep unfinished work moving and carry it into a new chat.

    View prompt
    Using the repo totec448-spec/chat-on-steroids, set the goal <goal-description> for the project at <project-path> and use Loop within the brief I give. When the chat is long, run Compact & Resume. Expected output: a summary of finished and unfinished items after the resume. Verify that the unfinished items match the original goal.

  • Test the vibration engine with a mock controller

    Run a fake Intiface Central server and the test suite to check the daemon without any device.

    View prompt
    In the transkatgirl/vibeclaude repo, start node test/mock-intiface.mjs 12345 in the background, then run npm test. Report the test result and the motor levels printed by the mock. Verify that the mock printed at least one motor level value.

  • Run the web question checks locally before a pull request

    Install the web app and run the Pyodide check that tests every reference solution.

    View prompt
    In the TrenTorch repo, enter TrenTorch_Web, run `npm install` and `npm run test:pyodide`, then report the number of questions checked and any failing reference solutions by name. Verify the command exits with code 0 before claiming success.

  • Run a saved agent on a schedule and review each session

    Save an agent once, run it on a recurring cadence without you present, and audit each run.

    View prompt
    Using the truefoundry/trueforge repo, take the saved agent named <agent-name> and set a schedule that runs it every <cadence>. After one scheduled run, report its session ID and tool call count from Sessions. Verify that the run completed without a pending approval.

  • Let a coding agent send and read email through MCP tools

    Connect the sentio-mcp server so an agent can call email actions as native tools.

    View prompt
    In the truespar/sentio repo, follow the README section 'MCP: give agents email as native tools' to register the sentio-mcp server with this agent. Then send one test email to <test-address> through the Sentio REST API and report the message ID. Verify the message appears in the outbound queue.

  • Pull brand data and a LinkedIn profile into a prospect record

    Add a Context key in Settings → General so accounts show real logos, names and LinkedIn roles.

    View prompt
    In the trycompai/crm CRM, confirm that the Context key is set under Settings → General, then trigger enrichment for the company <company-domain> and the contact <linkedin-url>. Report the logo, industry, current title and employer that were recorded. Verify that the startup list shows both Company brand data and LinkedIn as on.

  • Import all GitHub issues into a local task backlog

    Pull a repository's issues into Reslop tasks so they sit next to the review plan.

    View prompt
    In reslop for the repository at <repo-path>, import the issues from <issues-URL> and list the task titles added to the local plan. Report the number imported. Verify the count matches the open issue count shown on the hosting site.

  • Review and merge simplification findings from a PR

    Check simplification suggestions from a pull request or another agent, keeping the evidence and dropping the rest.

    View prompt
    Use $simplify-codebase to review and consolidate the simplification suggestions in <PR link or notes file>. Keep only findings with evidence and reject the rest with a reason. Expected output: a consolidated list with proof records and rejected items. Verify that every kept finding names its consumers and deletion boundary.

  • Check pack integrity and tests before trusting an install

    Run the hash check and coach test suite to confirm the pack has not been altered.

    View prompt
    In the ai-memory-skillpack repo, run sha256sum -c SHA256SUMS and the tests/run.sh command for project_mastery_state.py. Expected output: each hash line reported OK and the test runner exit status. Verify that the agent reports failure and makes no install changes if any hash fails.

  • Break a reference film into shots and rhythm notes

    Turn a video you admire into a shot list, rhythm stats and a contact sheet to learn its grammar.

    View prompt
    Use the saas-motion-kit repo. Run `python tools/breakdown.py <video file> --id 01 --creator "<creator>" --title "<title>" --url <link>` on the reference video. Expected output: a shot breakdown, rhythm stats, a contact sheet and a draft ledger in .references/. Verify that the credit header names the creator and link before any output is reused.

  • Pull every line item from a document into a typed list

    Return a variable-length array of typed objects, such as one object per invoice line.

    View prompt
    Using the TypeLLM/TypeLLM package, extract every line item from <document_path> as an array of objects with description, quantity and unit_price. Return the list from response.result. Verify the count of items matches the number of line rows you can see in the document.

  • Gate a build or pipeline on fresh video sidecars

    Use Cdaf validate as an exit-code check so stale descriptions never reach downstream steps.

    View prompt
    Using the CDAF CLI from the repo UditAkhourii/cdaf, run `cdaf validate` on each video path in <video-list> and report the exit code for each. Stop and list any video whose sidecar is missing or stale, and verify that validate exits 0 for every video that passes.

  • Get a cited algorithm brief from the terminal

    Run the Neuroarxiv CLI on a hard problem and read one recommended approach with citations.

    View prompt
    In the UditAkhourii/neuroarxiv repo, run `neuroarxiv "<problem>" --papers 6` and return the recommended cluster, its cited arXiv links, the first step, and the risk. Confirm that each cited arXiv id appears in the fetched metadata before reporting it.

  • Sort a batch of tickets or issues into labels in one pass

    Send a JSONL file of items to Jev with a closed label set and get back id lists per label.

    View prompt
    Using the repo UditAkhourii/quicksilver, run qs classify with a closed label set against <items-file>.jsonl. Return the id list for each label and count how many items landed in the catch-all label. Verify that the total of ids across labels equals the number of items in the file.

  • Fix Blueprint and C++ compile errors with a goal checklist

    Run goal mode to repair compile errors and verify each requirement in the project.

    View prompt
    In the ueboxai/uebox app with the Unreal project <project path> open, use /goal with this checklist: <requirements>. Report which items pass after the final round and list the files and assets changed. Verify by checking that the compile step reports no Blueprint or C++ errors.

  • Move a team UFO server onto Postgres

    Point the server at a local Postgres database before creating the workspace.

    View prompt
    In the ufo-core repo, run `make db`, write ufo.toml as the README's Postgres section describes, then run `make init EMAIL=<work email>` and `make serve`. Expected output: the server starts on http://localhost:8710 against postgresql+asyncpg on 127.0.0.1:5541. Verify that ufo.toml contains the postgresql+asyncpg URL before you report success.

  • Wake an on-call agent the moment logs or metrics spike

    A watch on your logs or metrics wakes an agent within seconds to find the cause and fix or roll back.

    View prompt
    Using the Overtime repo at ukanwat/overtime, create an on-call agent with a watch on <log or metric source>. Expected output: after a test alert, a cause summary, the action taken, and a postmortem file. Verify that the agent wakes within the watch interval and asks before any change it has not been permitted to make.

  • Audit an agent setup with the agents course plugin

    Install the course's Claude Code plugin in two commands and run its context auditor.

    View prompt
    Install the agents-course plugin from undefined-ui/second-brain-os in Claude Code, then run its context auditor on <target-repo>. Output the auditor's findings as a list of context problems with file paths. Verify that each finding names a specific file.

  • Build a custom agent tool on the harness library

    Write a tool with a schema and translator that turns model tool calls into async operations.

    View prompt
    In the unreal-agent repo at <repo path>, add a tool named <tool name> with a schema and a translator that returns serializable operations for <task>. Expected output: a model-facing result produced from the operation output. Verify that the translator performs no I/O and that the operation is serializable.

  • Add a community extension from a Git repository

    Install a Rune extension straight from a GitHub repo to add themes or other features.

    View prompt
    For the repo unstablebuild/rune, check that Rune is installed, then run `pkg install <git-repo-path>` with the target extension path from a community repository and report the install result. Verify by listing that the extension appears in Rune.

  • Run a research report or spreadsheet with a free model

    Ask an agent for research, a website or a spreadsheet from the web app and keep the files it makes.

    View prompt
    Using the UseAgent hosted app with a free model, start a thread that asks the agent to research <topic> and produce a spreadsheet of <number> sources. Expected output: a spreadsheet file attached to the thread. Verify that every row in the spreadsheet includes a source link.

  • Get a thread woken when a PR checks, comments, or conflicts

    Watch an open pull request so the agent reacts to CI results and review comments.

    View prompt
    In the repo at <repo-path>, open a PR for branch <branch>, then call watch_pull_request on it. Expected output: the PR link and a note on each wake event (checks, comment, or conflict). Verify that the thread wakes on a real check completion rather than on a timer.

  • Check subscription usage before a long run

    Read rate-limit windows and reset times in the composer and provider cards before starting heavy work.

    View prompt
    Using the dsh-plugin-subscriptions repo, open the subscription usage details for the logged-in <provider> account in DSH. Expected output: the used percentage and reset time for each rate-limit window. Verify that the values changed after clicking Refresh.

  • Gate a cheap model's answers with a Jev check

    Let a low-cost model answer first and escalate only the answers Jev rejects.

    View prompt
    Follow the cookbook at https://openrouter.ai/docs/cookbook/evaluate-and-optimize/jev-verified-cascade to build a cascade for <task> that uses typesafe/jev-1.13 as the checker. Expected output: a function that returns the cheap answer when the check passes and the escalated answer when it fails. Verify that the threshold is set from a labeled sample, not guessed.

  • Ask questions about pictures without uploading them

    Send screenshots or photos to a local vision model that reads images on your PC.

    View prompt
    Using the PolyStrata server on localhost with <vision model name>, send the image <image path> and ask: <question>. Expected output: a text answer describing the image. Verify that the answer matches what is visible in the image and that the image was not sent to any remote service.

  • Ask many questions of one indexed annual report

    Uploads a report once, then reuses its doc_id to answer each new question.

    View prompt
    Using the repo VectifyAI/jev-doc-search, upload <path-to-pdf> once with tree_search.py, then run it with the returned doc_id for each question in <question-list>. Output the kept pages per question. Verify that the doc_id stays the same across runs and that each answer page matches the question's topic.

  • Render an HTML motion graphic to a frame-exact video

    Turn an HTML page with animations into a silent H.264 video, frame by frame.

    View prompt
    In the veedstudio/open-edit repo, render <page.html> to out.mp4 with the render command and a duration matching the page timing. Expect a silent MP4 that matches the animation timing. Verify that the output is not a single flat colour before you deliver it.

  • Delegate a Linear task to the factory and track it in Linear

    Assign a Linear task to the factory and follow its progress inside Linear.

    View prompt
    Delegate the Linear issue <linear-issue-id> to the factory for the repository <owner/repo>. Verify that progress updates appear in the Linear issue and that the run ends with a draft pull request on <owner/repo>.

  • Audit a page's SEO and get a ranked fix list

    Ask the SEO specialist to review a page for structure, internal links, and schema and return recommendations.

    View prompt
    Using vercel-labs/marketing-team-eve-template, ask the lead agent to have the seo specialist audit <page URL> for hierarchy, internal linking, and JSON-LD schema. Expected output: prioritized recommendations, with a long audit as an artifact if it is large. Verify that each recommendation names the specific element on the page it refers to.

  • Keep installed agent Skills up to date

    Check for newer versions of installed Skills, update them, or remove the ones you no longer use.

    View prompt
    Use the vercel-labs/skills CLI in this project to list installed skills, check for available updates, and update <skill name>. Report which skills changed and which were already current. Verify the list again after the update.

  • Continue a DSH session from a phone or browser

    Enable remote access on your computer and keep the same session open from Remote Web or Android.

    View prompt
    For the vibeinging/dsh-desktop project, confirm that the ds-harness-remote bundle is installed in <profile> and report whether remote access is enabled for the current computer. Verify that the Host opens only outbound connections, as the README states, and that no public listening port is exposed.

  • Run coding agents on a VPS or remote server

    Connect a remote Linux machine so agents run there while you start them from your desktop or phone.

    View prompt
    Using the vicoa-ai/vicoa repo, connect the VPS at <server-address> as a Vicoa machine and start a Codex session on <remote-project-path>. Confirm the VPS appears as a machine option and the session starts there. Report the machine name and session status.

  • Create an interactive lesson on eigenvectors or Bloch spheres

    Build a runnable visual study for a math or quantum topic from the catalog.

    View prompt
    Using the 3dviz-pro-max skill in <repo-path>, build a runnable interactive Three.js study on <topic, for example eigenvectors or the single-qubit Bloch ball>, starting from a matching recipe or example study. Report which catalog entry was used and which frames show the key points.

  • Audit saved routing rules for conflicts and shadowing

    Run the local Policy Intelligence report to find duplicate, shadowed, and conflicting rules without any AI call.

    View prompt
    Using the Vincent-Xi08/IntentRoute-AI repo, open the local Policy Intelligence report for the saved configuration at <config path>. Expected output: a list of findings with codes, categories, severities, and affected-rule counts. Verify that the report made no provider request and wrote no file.

  • Render one video in wide and tall sizes at once

    Make one project into a YouTube video and a TikTok or Reels version in one step.

    View prompt
    In the explainroo repo at <repo folder>, render the project at videos/<project> in the wide size and the tiktok size. Expected output: two MP4 files next to each other. Verify that the tall version keeps your text clear of the platform buttons before you upload.

  • Build a video from your own narration audio

    Use the Remotion template with finished audio and a hand-filled timeline instead of the built-in TTS.

    View prompt
    In the anything2explainer repo, scaffold a new Remotion project at ~/work/<slug> with template/scripts/new_project.sh, add my finished audio file <path-to-audio> with a hand-filled timeline and subtitles, and render a 30-second preview. Verify that the preview plays with the audio and that subtitles line up with the spoken words.

  • Filter abstract Pi responses with a rewrite request

    Install the Nopus Pi extension to check completed responses and hide rejected ones from the transcript.

    View prompt
    Using the nopus repo at Vistyy/nopus, install the Pi extension with `pi install npm:@syzom/nopus`, start Pi in <project directory>, and run `/nopus status`. Expected output: a status report showing nopus is active. Verify that a rejected response stays in the Pi session history even though it is hidden from the terminal transcript.

  • Let agent sessions search and message each other

    Use vsearch, vrefer and vtell so one agent can pull in work from another session.

    View prompt
    In the VelaTerm project at <project-path>, have one agent session use vsearch to find earlier work on <topic>, then vrefer to read the best match. Expected output: a short summary of the matched conversation with its session name. Verify that the summary cites a real session from the tree before you act on it.

  • Query and branch Neon Postgres from an AI assistant

    Connect the Neon MCP server so an assistant can manage Neon projects and branches for a Postgres database.

    View prompt
    Using the Neon MCP server from VoltAgent/official-mcp-servers, list the projects and branches in my Neon account and identify the branch named <branch-name>. Report the project ID and branch state. Verify the branch exists in the list before reporting anything about it.

  • Coordinate parallel agents with one writer for publication

    Let workers prepare and inspect while one writer owns publication and cursor movement.

    View prompt
    Using the forward-implementation-first skill in <repo-name>, assign one agent as the single writer for publication and cursor movement, and have the other workers prepare and inspect <target-task>. Report the worker outputs that were verified before consumption and the final publication. Verify that no worker output was merged without a check.

  • Answer factual questions from Wikipedia and web search

    Get sourced facts from Wikipedia and Brave Search, with no model writing the answer.

    View prompt
    In the jev-chat repo, run pnpm dev with TYPESAFE_API_KEY set in .env, then send "How tall is Mount Rainier?" to the chat at http://localhost:5173. Report the reply and the tool named in the inspector. Verify that the height value appears in the tool result shown in the inspector.

  • Choose a browser agent demo before delegating a search task

    Use the flight search and browser agent entries to scope a delegated web task.

    View prompt
    Using the repo walidboulanouar/awesome-jev-use-cases, read the Agents and computer use section and write a plan for a browser agent that searches for <target-query> and returns a list of results. Verify that the plan names one input, one output format and one stop condition.

  • Quote a HERO case ID when an agent defends its extra checks

    Point the agent to a named catalogue case when it insists a hash or extra review is needed.

    View prompt
    Read cases/README.md in the HERO-Anti-OverDefense repo. Find the case that matches <behaviour you observed>, quote its ID and its proportionate example, and answer in one paragraph whether the check you are about to run would detect a failure that changes what happens next.

  • Let an AI agent render diagrams through the MCP server

    Connect an agent over MCP stdio so it can read documents in one approved folder and render diagrams.

    View prompt
    Using the architecture-canvas repo at https://github.com/weike-zhang/architecture-canvas, start python3 mcp_server.py with --root set to <authorized-docs-dir> and call the document reading tool on <document-name>. Expected output: a rendered diagram or document text limited to that folder. Verify that a path outside the --root folder is refused.

  • Review a community mod before you install it

    Read a third-party mod's own repository and check its mod API use before running it.

    View prompt
    Review the community Claude Code mod at <repository URL>, listed in wh000wh000/awesome-claude-mods. Report which mod APIs it uses, every shell command or network call in its install and hook code, and a go or no-go recommendation with reasons. Verify that the report cites specific file paths from the repository.

  • Shortlist Jev clients using evidence grades only

    Filter the index to projects that were opened and read, skipping unverified ones.

    View prompt
    Using the awesome-jev-live README, build a shortlist of Jev tools for <your purpose> that includes only official and observed entries. Output a table with name, grade, language, last push and category, and flag any entry you could not open.

  • Keep sensitive chats locked on your device

    Use locked chats so messages are encrypted on your device and answered only by zero-retention models.

    View prompt
    In the whirlchat/whirl repo, read the README's Locked chats feature and the docs/architecture.md file, then explain how a locked chat is encrypted and which models answer it. Output a short summary with two cited facts. Verify that every claim appears in the README or docs.

  • Run multi-turn RL against vLLM or SGLang rollouts

    Train a policy with asynchronous GRPO where Ray actors roll out environments on vLLM or SGLang.

    View prompt
    In the whitecircle/halo repo, read human-docs/training-methods/async-grpo-environments.md and then launch the environmental-grpo method with <target-config> inside the Halo image. Expected output: a running async GRPO job that reports rollouts and weight syncs. Verify with `halo launch --list` that environmental-grpo is available before launching.

  • Install, update, and toggle agent plugins from npm or Git

    Add new agent capabilities by installing plugins, checking for updates, and enabling or disabling each one.

    View prompt
    In the DSHCode app, install the plugin <npm package or Git URL> using the built-in plugin installer, enable it, and report its name and version. Verify that it appears in the plugin list and that the app still starts after a restart.

  • Generate images in 8 steps with the official Turbo model

    Use Qwen's own 8-step checkpoint with CFG 1.0 for faster generation.

    View prompt
    Using wildminder/awesome-qwen-image, load Qwen/Qwen-Image-2.1-Turbo in a diffusers build that supports pipeline-configured sampling and generate one image in 8 steps with CFG 1.0 from the prompt <prompt>. Report the output path and the step and CFG values. Verify that the sampler was configured by the pipeline and not set by hand.

  • Get a blind critique of your pixel art before shipping

    Have a separate critic judge your sprite cold and fix only the blockers it names.

    View prompt
    Using the aseprite-ai-artist plugin from with-pebbly/aseprite-ai-artist, review the open sprite <sprite name> with the pixel-critic, write a cold read, and fix only the blocking issues it names. Expected output: the cold read, the score, and a list of which fixes were kept. Verify that each kept fix was preferred in the blind A/B comparison.

  • Add providers and client keys behind one gateway

    Configure AI providers and named client keys once, then point every client at CPA.

    View prompt
    In the Oh My CPA console at http://127.0.0.1:8080/omc/, add one <provider-name> provider and one client key named <client-name>. Report the provider's status and the key name. Verify with a Playground request that the routed model answers before you finish.

  • Train the Z-Image-Turbo backbone at 1024 resolution

    Run Diffusion OPSD on the few-step Z-Image-Turbo regime at 1024 pixels.

    View prompt
    In the repo worldbench/DiffusionOPSD, confirm ZImagePipeline imports in the installed Diffusers, then start the Z-Image-Turbo training preset for <reward name>. Report the import check result, the launch command, and the first logged seconds per update. Verify that the import check passed before launching training.

  • Serve Spark-X2.6-4B with vLLM for an OpenAI-style API

    Deploy the model with the official vLLM Docker image and prefix caching turned on.

    View prompt
    Using the Spark-X2.6 README vLLM NVIDIA deployment block, start vllm/vllm-openai:latest with the model at <MODEL_PATH> mounted and served as spark25 on port 30000. Send <your prompt> to the chat completions endpoint and return the reply. Verify that the response contains a non-empty message content field.

  • Keep DSH configuration in step between machines through Git, WebDAV, S3 or Gist

    Push and pull portable configuration through a remote channel, with optional encrypted credentials.

    View prompt
    Configure the DSH Config Manager plugin on <machine> to sync portable configuration to <channel> (Git, WebDAV, S3-compatible or Gist). Run a push, then confirm on <other-machine> that a pull shows the same sections and that the remote holds only encrypted content if credentials were exported.

  • Check paper discovery against the 15-paper smoke corpus

    Run the deterministic discovery and evidence gate on pinned public papers.

    View prompt
    Using the VeriRepro repo (XiantingWu/VeriRepro), clone the repository, install it with `python -m pip install -e '.[dev]'`, and run `python scripts/run_real_paper_smoke.py --require-top1 --require-evidence`. Expected output is a gate result over the 15 pinned papers. Verify the gate result and report any failing papers without claiming that all 15 were fully reproduced.

  • Keep .env and key files out of ChatGPT reviews

    Use the default sensitive-file rules plus your own .c2cignore patterns to protect secrets.

    View prompt
    In the workspace at <workspace path>, add the pattern <pattern> to .c2cignore, then run c2c status and c2c doctor and report their output. Confirm that the sensitive-file rules still deny .env files.

  • Enforce coding rules and reusable workflows for ChatGPT

    Store coding conventions as Rules and step-by-step workflows as Skills the Agent loads on demand.

    View prompt
    Using the openchatx-mcp repo, create a Rule in the <toolbox-name> Toolbox that applies to files matching <glob>, and create a Skill named <skill-name>. Then edit a file matching <glob> and report which Rule was applied. Verify that the Rule text appears in the Agent's working context before it edits the file.

  • Confirm a local rebuild matches the published benchmark

    Check your rebuilt twins against the hashes the repository publishes, file by file.

    View prompt
    Use the keystone-bench package to rebuild the release with keystone build, then run keystone build --check. Report whether every file matches the published hashes and list any file that does not, along with the output of keystone pairs.

  • Screen a product idea with the Douyin selection Skills

    Load the Douyin public-knowledge Skills to check a product idea before buying inventory.

    View prompt
    Using the sealeap-amazon-skills repo, run a selection Skill from amazon-skills/douyin/ on the product idea <product idea> for <marketplace>. Expect an input checklist, the decision basis, a step-by-step screen, and a list of unknown data. Check that the agent marks every missing number as unknown rather than estimating it as fact.

  • Write feature docs so AI finds code without full reads

    Keep short docs for each important feature so the AI can locate code and behavior quickly.

    View prompt
    In <project path>, write a documentation file for the <feature name> part that explains what it does, how it behaves and which files relate to it. Expected output: one doc file in the project's docs area. Verify that the doc ends with a list of any open follow-up items.

  • Query a SQL database while redacting personal data before the LLM sees it

    Ask questions about a PostgreSQL, MySQL, SQL Server, Oracle, or Dameng database with privacy protection on.

    View prompt
    Using the Baize CLI from the Xu123-Bob/Baize repo with privacy protection on, ask it to count rows in <table-name> of <database-name> and summarize the result. Expected output: a row count and a short summary with no raw personal values. Verify that no phone number or email appears in the LLM-facing prompt log.

  • Run the LoCoMo benchmark on a memory system

    Score Voice Mem on the LoCoMo dataset and check that the parser reads the data correctly first.

    View prompt
    In the VoiceMem repo at <repo path>, run the LoCoMo sample with evaluation/run.py, then run the full dataset only after the sample passes. Report the overall score, the per-category scores, and median retrieval latency. Verify that the answer model received retrieved memory and not raw conversation history.

  • Benchmark a Strix Halo machine and share results

    Measure prefill and speculative decode speed on your own 128 GB AMD box and export the numbers as JSON.

    View prompt
    In the Yamz-Labs/kyojin repo, run tools/bench.sh --json on <target machine> after reading doc/benchmarks.md. Expected output: a JSON benchmark result with prefill and speculative decode tokens per second. Verify that the figures are labeled with the context length and model used before comparing them to the README tables.

  • Triage your inbox on a schedule in your own voice

    Label and draft replies to email on a recurring schedule, using your past sends as style.

    View prompt
    Using the repository yc-software/qm, set up a scheduled inbox triage for <person's email account>. Learn the writing voice from past sent mail, then label incoming messages and create reply drafts without sending them. Verify that no message was sent and that each draft is saved for review.

  • Study Mixture of Experts layers in two models

    Read the MoE implementations in the DeepSeek v3 and Llama 4 Maverick folders to see how experts are used.

    View prompt
    In the repo YeonwooSung/llm-architecture-from-scratch, open the deepseekv3 and llama4_maverick folders and describe how each one implements its Mixture of Experts layer. Output a comparison table of expert structure and routing. Verify each claim against the code in the folder before reporting.

  • Catch agent retry loops before they burn your session

    Detect repeated Bash failures and edit or retry cycles with evidence and investigation prompts.

    View prompt
    Using the repo YeonwooSung/my-claude-code-mods, install loop-detective at user scope and run a session on <task description>. Report every flagged repeated Bash failure or edit/retry cycle with its evidence and the investigation prompt shown. Verify that each flagged case cites at least two matching attempts from the session before you report it.

  • Produce an AI short-drama episode with consistent characters

    Write an outline and script, store characters and scenes in the asset library, and turn episodes into shots.

    View prompt
    Using the printfilm AI 漫剧 feature at http://localhost:8080, create a project named <project name> with the script in <script file>, add the recurring characters to the asset library, and parse episode 1 into shots. Report the shot count and confirm that each character is linked to its assets.

  • Spot same-day bulk submissions before trusting them

    Check commit history and shared scaffold files to see if a bulk-submitted repo is proven.

    View prompt
    Using the Curation is not endorsement section of yibie/awesome-jev as the reference, inspect <repo URL> for commit count, commit dates, the presence of AGENTS.md, CLAUDE.md, STATE.md, and CHANGELOG.md, and the ratio of code to prose files. Expected output: a short verdict of proven, unproven, or unclear with the evidence listed. Verify the verdict against the commit history shown on the repository page.

  • Pick the next game action from an image

    Choose the best next move from a board image using a multimodal Choice question.

    View prompt
    Using the LLM2Jev repo, run the single-step Sokoban evaluator against the running SGLang service on <image-folder> with the multimodal Choice pipeline. Return the chosen action and option probabilities for each image as JSON. Verify that the output count matches the number of images before reporting.

  • Export an explainer as slides or a document for a briefing

    Turn a rendered explainer into PPTX, DOCX, PDF, or PNG output for a team meeting.

    View prompt
    Using the fireworks-open-eli5 Skill, render <spec.json> to <output.html> and report the export options available for a team briefing. Confirm the rendered HTML validates with the validate script before any export.

  • Measure your own session with the graded metrics script

    Run the measurement script on a session log to get numeric metrics without exposing the session content.

    View prompt
    In the repository yjh051108/dsh-routing-suite, go to the graded folder and run `node scripts/measure.mjs <session-file>.jsonl` on the session file <session-file>.jsonl. Return only the numeric output. Verify that the output contains numbers only and no session text.

  • Render ad creative with exact on-image copy

    Use ad prompts that quote their text so the headline and call to action appear as written.

    View prompt
    Using the ad creative prompts in prompts/gpt-image-2-5-ad-creative-prompts.md from the awesome-gpt-image-2-5-prompts repo, choose the prompt that fits <campaign brief], replace its quoted strings with the copy in <copy deck>, and return the prompt. Verify that every quoted string matches the copy deck character for character.

  • Set up the Copilot model connector with one script

    Run the platform setup script to install the extension and prepare the connector.

    View prompt
    Using the repo yudaprasetya007/routeVSCODE, run the setup script for this platform (scripts/setup.sh on Linux or macOS, scripts\setup.bat on Windows) and report the output. Verify that the file releases/routevscode.model-connector-2.5.0.vsix was installed into VSCode and that the command `9Router: Status & Info` shows the proxy port 20129.

  • Try PairTeX on the bundled demo fixture

    Run the isolated demo to see comments, Edit and Review modes, and section navigation.

    View prompt
    Clone the PairTeX repository and run `python3 pairtex.py --project demo/fixture --html demo/fixture/rendered.html --port 8765` from its root. Report the URL that PairTeX prints and list the files created under demo/fixture/.pairtex/feedback/, then confirm that demo/fixture/main.tex was not modified.

  • Confirm the scenario catalog is intact before scoring

    Verify that the catalog loads and contains 94 scenarios before any scoring run.

    View prompt
    In the repo YuyaoGe/doc2harness, run the Python sanity check that imports active_scenario_ids and prints its length. Report the printed number and any digest error. Verify that the output is exactly 94 before reporting the catalog as intact.

  • Generate and grade 20 copy variants before review

    Produce 15-20 copy variants, score them with an expert panel, and strip AI-sounding phrasing.

    View prompt
    Using the marketing-os skill in the Yuzzyuk/marketing-os repo, run the copy module on the brief for <product or offer> and return 15-20 variants with expert-panel scores and de-slopped text. Verify that the top variants are ranked by score and that the scores are described as heuristics.

  • Render DMAD clips in ComfyUI with ready-made workflows

    Load the ComfyUI-layout DMAD LoRA and a ready-to-run workflow to make 4-step or 8-step clips with audio.

    View prompt
    In the Yzmblog/DMAD repo, open the ComfyUI workflow described in comfyui/README.md and load dmad_minimax_h3_4step_lora_critic_comfyui.safetensors with the lcm sampler and simple scheduler. Expected output: a 15 s video with audio for the prompt <your prompt>. Verify that the sampler and scheduler names match the README before running.

  • Package the zcode command and test it locally

    Build the release bundle, unpack it to a debug folder and start Web mode from it.

    View prompt
    In the zai-org/ZCode repo, run `pnpm build:zcode --base-url <download-root-url>`, extract the tarball listed in dist/zcode/latest.json into dist/zcode/debug, and start it with --web on port 3030. Report the URL and confirm that http://127.0.0.1:3030 returns a page.

  • Plan an authorized engagement and assemble findings

    Turn your rules of engagement into a plan, then build evidence-backed findings and a report draft.

    View prompt
    Using the engagement-operations skills from the zero-lab-ai/skills repo, draft an engagement plan for <client-name> based only on the rules of engagement I provide. Return the plan, a findings list with evidence references, and a report outline. Verify that no target or action appears that is outside the scope I gave.

  • Host the Web UI for a team with login enabled

    Deploy the web interface on a shared server with password authentication and local terminal access turned off.

    View prompt
    Using the AI Security Tool repo at https://github.com/ZeroDayEvil/ai-security-tool, configure the .env file with ENABLE_AUTH=1 and DISABLE_LOCAL_TERMINAL=1 and start the web service for <domain-name>. Expected output: the service starts and the public URL shows a password prompt. Verify that an unauthenticated request to the URL is refused before the Web UI loads.

  • Rename functions and add notes with agent changes you approve

    Let an agent rename functions and leave notes while you accept each change and keep an undo trail.

    View prompt
    In the Zfinix/eleven app, open the project for <target-binary>, ask the agent to rename the functions it can explain with confidence, and add a note to each. Expected output is a list of accepted and declined renames; verify that each change appears in the change log with the agent as its author.

  • Classify a new agent paper against the taxonomy

    Place a new paper in the existing update-target taxonomy using the taxonomy data file.

    View prompt
    Read data/taxonomy.json in the zgcagi/Harness-RSI repo at https://github.com/zgcagi/Harness-RSI and classify the paper described by <paper title and abstract> into one existing category. Output the category name, the nearest listed entry, and a one-sentence reason. Verify that the category name appears in the file before you answer.

  • Assign different models to DSH planner and subagent roles

    Send planner and subagent roles to different configured models inside DSH.

    View prompt
    Read the README of the repository at <plugin repo URL> (dsh-role-router) and list the role names it supports and how a role is mapped to a model. Expected output: a mapping table for <target project> with planner and subagent roles. Verify that the README confirms the routing summary is shown in DSH Web before you include that step.

  • Unpack DeepSeek Harness as a portable build on Raspberry Pi 5

    Extract the arm64 .tar.gz on a Raspberry Pi 5 and launch it from the unpacked folder.

    View prompt
    For the repo Zhou-Yujing114514/deepseek-harness-linux, download the arm64 .tar.gz to <target-folder> on a Raspberry Pi 5, extract it with `tar -xzf deepseek-harness-*-linux-arm64.tar.gz`, and start `./deepseek-harness` from the extracted folder. Report whether the desktop window opens and the value of DISPLAY used. Verify that the process is still running after 10 seconds.

  • Spot paid AI products and new sellers early

    Find AI products with verified revenue and sites that just added a payment link.

    View prompt
    Using the new-term-radar repo, run the weekly revenue and sellers signals with my config at <config path> and return the products and sites they report. Verify that each product entry shows its source and that the revenue figures match the TrustMRR data before you quote them.

  • Run the desktop app from source for development

    Install Node.js and Rust, then start Unbagrnd in dev mode with hot reload.

    View prompt
    Clone github.com/zidniryi/unbagrnd, install dependencies with npm, and start the app with npm run tauri dev. Expected output: the unbagrnd window opens. Verify that the app starts without build errors and that the frontend loads.

  • Regression-test an OCR model on six synthetic hard cases

    Check a transcription model on crossed-out, decimal, and mixed-operation handwriting with public hashes.

    View prompt
    Clone https://github.com/znxzsy/VeriInk, read examples/hardcases/manifest.json, and verify the SHA256 of each synthetic image. Run <model-name> on the six images and report, for each image, whether the transcription matches the visible answer. Verify that every hash matches before you score the model.

  • Learn coding agent harnesses with Claude Code or Cursor

    Work through Phase 4 harness lessons using the tools the course names.

    View prompt
    In the AI-Engineering-Lab repo, read the Claude Code and Cursor guides under reference/skills and the Week 12 folder under curriculum/. Summarize the harness steps for the Week 12 exercise and list the one metric the exercise asks for.

  • Confirm a like or count changes by exactly one

    Tap a row action in a list and check that its counter moved by exactly plus or minus one.

    View prompt
    Using the dsh-android plugin, call android_ui_rows on the streamed device, then call android_tap_row with index <row index> and expect_count set to {key: <counter key from the listing>, delta: 1}. Expected output: a result showing the counter's before and after values and whether it moved by exactly 1. Verify the result reports a match before marking the test as passed.

  • Check that a list row counter moves after a tap

    Tap a like or reply action inside a feed row and confirm the counter changed by exactly one.

    View prompt
    Use the dsh-ios plugin in the ZSeven-W/dsh-ios repo to call ios_sim_ui_rows on the simulator <udid>, then ios_sim_tap_row at index <index> with expect_count set to <key> and delta <delta>. Report countCheck.verified and the counter values. Verify that countCheck.verified is true before you report success.

  • Run the evolved Qwen3-VL-2B programs on your charts

    Set up the recorded GPU environment and model snapshots to run the selected programs on your own chart questions.

    View prompt
    In the EvoVLM repo at research/evolving-vlm-inference-main, follow the runtime guide README.md to set up pinned Qwen3-VL-2B snapshots and run the Evolved Instruct program on <path to your chart question file>. Report the answers, median latency, and accuracy against your labels. Verify that the environment matches requirements.lock.txt before comparing numbers.

  • Record application outcomes and draft follow-ups

    Log interviews, offers and silence, then get drafted follow-ups for applications that went quiet.

    View prompt
    In the ai-job-search repo, run /outcome followup. Expect a list of open applications quiet for 10 days or more and a short draft for each, using only claims from materials you already submitted. Verify that each draft contains no new claims and that no draft was sent.

  • Draft a literature review with traceable citations

    Synthesize papers on a topic and keep each claim linked to a citable source.

    View prompt
    Using the scientific-agent-skills repo and its evidence-traceable writing and literature synthesis skills, write a literature review on <topic> from the papers listed in <paper list>. Return a draft with a citation after each claim and a matching bibliography. Verify that every cited claim appears in the named source.

  • Run large open-source models on a modest GPU

    Use Comfy UI's memory management and quantized model support to run bigger models on a small GPU.

    View prompt
    Using the ComfyUI repo at https://github.com/Comfy-Org/ComfyUI, load a quantized version of <model name> on a machine with <GPU VRAM> VRAM and generate <output description>. Expected output: one generated file and a log showing the peak VRAM used. Verify the run finishes without an out-of-memory error.

  • Read and edit agent memory as plain markdown files

    Open the project's memory wiki in any text editor or Obsidian and correct it by hand.

    View prompt
    Using the ai-memory repo (github.com/akitaonrails/ai-memory), locate the markdown wiki for the project at <project-path>. Expected output: a list of .md page files that hold the project memory. Verify by opening one page and confirming its content matches a recent session summary.

  • Link design docs and PDFs to the code they describe

    Put docs, PDFs, and rationale comments into the same graph as the source they explain.

    View prompt
    Using the Graphify-Labs/graphify repo, run `/graphify <repo-path>` on the target project and then `graphify explain "<code-concept>"` for one concept that an ADR or RFC cites. Expected output is the concept's connections including the doc reference; verify the doc reference appears as a node before reporting the link.

  • Compare coding agents on one task in Git worktrees

    Run dsh-agent-arena to score coding agents in isolated worktrees and apply the winning change.

    View prompt
    Using the repo 0xsline/awesome-deepseek-harness, set up dsh-agent-arena from github:LeemanCheung/dsh-agent-arena against <project folder> with the task <task description>. Report each agent's validation result and score. Verify that no change is applied until an explicit winner is chosen.

  • Clone or design a custom voice with approval

    Create your own voice from a short sample or a written description, after you approve it.

    View prompt
    Using the repo 100yenadmin/fish-audio-hermes, clone a voice from <path to permitted recording> with the fish_voices tool and wait for my approval before the clone runs. Expected output: a new voice id in My voices. Verify that the speaker has given permission and that the new voice appears when you list your voices.

  • Check a support refund amount before it reaches a customer

    Run the customer support demo to see a wrong refund proposal rejected by its calculation.

    View prompt
    Using the ResiMind repo at <repo path>, run the customer support demo and show how a proposed refund is checked against the configured calculation. Expected output: the ¥259 proposal rejected against the ¥249 calculation. Verify that the rejection reason is shown and no refund is committed.

  • Preview how a bash command translates before running it

    Use the translate command to check the PowerShell output for a risky bash command first.

    View prompt
    Using the fauxnix CLI from the 20000419/fauxnix repo, run `fauxnix translate "find . -name '*.log' -mtime +7 -delete"` in <project-dir>. Expect the generated PowerShell to be printed without executing the delete, and verify the file filter matches only the log files you intend to remove.

  • Verify writer-training rewards and trajectories offline

    Run the offline test suite for writer training to confirm rewards and action handling before any RL run.

    View prompt
    In the SpeakerMem-R1 repo (2022hpsk/SpeakerMemR1), run the training test file code/speakermem_pkg/tests/test_training.py with the PYTHONPATH the README gives. Expected output is a pytest summary for the training tests. Verify that the test run passes before any change to the writer reward code is accepted.

  • Let a coding agent call Reverify's checks through MCP

    Connect Claude Code or Cursor to Reverify's MCP tools so the agent verifies its own claims.

    View prompt
    Using the reverify MCP server from the repo 2akouwu/reverify, verify each claim about <target binary> with re_verify_claim and recover prior grounded facts with re_ledger after any context reset. Report which claims were VERIFIED and which were REFUTED.

  • Install the Jev skill in Muse with one command

    Run the Muse install script from a Muse chat to add the skill to Muse.

    View prompt
    Ask Muse to run the install script from the building-with-typesafe-jev repo, then confirm the skill folder exists under ~/workspace/skills/. Report the folder path and whether the SKILL.md header was rewritten. Verify the install by starting a new chat and asking a Jev design question.

  • Run AbacusAI Bot from source to test changes

    Install dependencies and start the desktop app in development mode from the repository.

    View prompt
    In the abacusai-bot repository, use Node.js 22, run `corepack enable`, `pnpm install`, and `pnpm dev`, then report whether the desktop app window starts. Verify that the terminal shows no install errors before reporting success.

  • Regenerate LIBERO task specs with deterministic ordering

    Rebuild subgoal orders for LIBERO tasks using only the automatic sort, with no model calls.

    View prompt
    In the EvoBot repo at <repo path>, run `python scripts/gen_task_specs.py --no-llm`. Report how many task spec files were written and confirm that each has source set to deterministic. Verify by opening one spec and comparing its subgoals list with the reference_order field.

  • Switch Git worktrees and review diffs in a desktop app

    Move between Git worktrees from the sidebar and preview diffs and project files.

    View prompt
    Using the abcwyc/pi-agent-desktop README, explain how to switch to a Git worktree and preview a diff for the project at <project-path>. Expected output: the sidebar and preview steps in order. Verify that the README lists diffs among the previewable file types.

  • Reuse confirmed findings on a new binary

    Replay stored finding descriptions and successful queries against a later target.

    View prompt
    In the Ablation repo at ~/ablation, replay the stored confirmed finding descriptions and successful semantic queries against <new binary path>. Output each candidate match with the source finding it came from and a similarity note. Verify that every candidate is checked in the disassembly before it is reported as a finding.

  • Embed a ManimGX scene in a web page

    Run a Python scene in the browser with Pyodide and WebGPU, with no render server.

    View prompt
    Using the manimgx repo at github.com/academa-labs/manimgx, add a ManimGX scene to the web page at <target page> following the embed guide, installing with npm install manimgx. Expected output: the scene renders in the browser. Verify that the page renders the scene in a WebGPU-capable browser without a render server.

  • Diagnose and repair an ACRYL install that will not boot

    Use Acryl doctor and Acryl repair to find and fix a broken install, with backups and undo.

    View prompt
    Using the acryl repo at github.com/acryldev/acryl, run the ACRYL diagnostic on this machine, then run the repair if problems are found. Report the list of issues found and whether ACRYL boots afterward, and verify with `acryl` that the app starts.

  • Get a weekly health sweep that files issues for findings

    Run a monitor that checks the default branch and Factory health, then files findings as GitHub issues.

    View prompt
    For the factory installed in <target-repo>, run the monitor stage once and report the issues it would file. Expected output: a list of proposed issue titles and the default-branch or setup finding behind each. Verify that the stage lists findings before filing any issue.

  • Map AD findings to DORA, NIS2 and ENS controls

    Use the compliance-mapping skill to tie each technique you tested to a control family for an audit report.

    View prompt
    Using the Claude-AD repo (ADScanPro/Claude-AD), apply the compliance-mapping skill to these confirmed techniques from the authorized assessment: <technique-list>. Expected output is a table mapping each technique to a conceptual DORA, NIS2 or ENS control family. Verify that each mapping is labeled conceptual and confirmed against the auditor's own control catalog.

  • Review and correct what the agent has written

    Read, update, or delete the Markdown memory files an agent produced to keep the project knowledge accurate.

    View prompt
    Using the Operator Memory repo (https://github.com/aerovato/operator-memory), review the Markdown documents in <project-path>/.operator/ for the module <module-name>. Expected output: a list of documents that conflict with the code, with each one corrected or removed. Verify by starting a new session and checking the agent cites the corrected spec.

  • Find the right ECC skill for a task before starting work

    Ask ECC which skill fits a request, such as security reviews, from its 311 skills.

    View prompt
    Using the ECC package ecc-universal from github.com/affaan-m/ECC, run `npx [email protected] consult "<request>" --target claude` and return the top suggested skills with a one-line reason for each. Verify that each suggestion exists in the consult output before you use it.

  • Hand file edits on your Mac to Codex or Claude Code

    Let Comma read files on your Mac and delegate changes to an agent you already use.

    View prompt
    On a Mac with the Comma Mac app connected to Salix, ask Comma to read the files in <project folder> and pass the change <describe change> to Codex or Claude Code. Report the files changed and the commands run. Verify the result by reviewing the diff before accepting the Task.

  • Run a batch of coding tasks headless in CI or cron

    Use codeaf do with a timeout and JSON output to run unattended work from scripts.

    View prompt
    Use the CodeAF repo at Agent-Field/CodeAF. In a CI job for <repo-path>, run `codeaf do "<brief>" --timeout 30m --json`. Expected output: one JSON object and an exit code. Verify the JSON result and exit code match the work that landed on the branch, and that the job fails when the exit code is nonzero.

  • Read values from an open Electron app window

    Attach to a running Electron app, such as VS Code, and read what its window shows.

    View prompt
    Use the fastbrowse repo to read <value> from the open window titled <window title> in an Electron app listening on port <port>. Run `uv run fastbrowse "<task>" --cdp-port <port> --target-match <window title>` and return the answer. Verify that the window stays open after the run.

  • Run Agent Launcher from source to test a change

    Install dependencies, start the dev build, and run the verify and build checks on a local copy.

    View prompt
    Using the Agent Launcher repo at https://github.com/agent-launch/agent-launcher, install dependencies with `pnpm install` and run `pnpm verify`, then report the result for branch <branch-name>. Expected output: pass or fail for each check. Verify that `pnpm build` completes without errors before proposing any change.

  • Pick a browser agent for repetitive website tasks

    Choose between the listed browser agents by license and hosting for web task automation.

    View prompt
    Use the Browser agents section of the Agenta-AI awesome-ai-agent-platforms repo to compare the listed browser agents by license and hosting. Recommend one for <website task>, and state the expected output of a single test run. Verify the license against the project's GitHub page before reporting.

  • Recover owner sign-in through a trusted agent

    Let one trusted agent mint a one-time sign-in link after you ask, if you have granted that permission.

    View prompt
    Run `agentpeerchat web --login` for me only when I explicitly ask, send the one-time link to me privately, and report whether the link was created. Never store the link in logs, reports or Git commits.

  • Run recurring office jobs and get weekly reports

    Put team jobs on a clock and receive scheduled outcomes as quiet Report cards on Needs you.

    View prompt
    Using the repo agentvivekkumar/dontbemichael, add a weekday 9 am schedule called Follow up on unpaid invoices to the Finance team member. Report the schedule entry as shown on Michael's Office schedule tab. Verify that the first run produces a Report card on Needs you.

  • Connect Claude Code to your Obsidian vault over MCP

    Point Claude Code at Local REST API so it can read, search, and patch notes.

    View prompt
    Using the Obsidian MCP server at http://127.0.0.1:27123/mcp for the Compass vault at <vault path>, list the available tools and search for notes tagged example. Expected output: the tool names and a count of matching notes. Verify that no note was written or patched during the check.

  • Plug a private agent into the shadow queue

    Use the ShadowWorker Python class to run your own handler against parked tasks.

    View prompt
    Use the repo AhmadHassan-BTed/AutoSwarm-Shadow-Adapter to build a ShadowWorker with a custom_handler that calls <private model or database> for the <role> role. Expected output: a Python script that runs forever and returns one string per task. Verify that the handler's returned text appears as the deliverable for a parked task.

  • Set a price for your developer tool

    Stop guessing a number and see how to charge without giving the product away.

    View prompt
    Run pricing and market-to-devs-sell-to-buyers in the gtm-cofounder skills for <product name>. Expected output: a pricing recommendation with the reasoning and the evidence still missing. Verify that the recommendation names what real users need to confirm before the price is locked.

  • Send applications from Gmail and draft replies to employers

    Send each application from your own address with its PDFs, then draft answers to employer replies.

    View prompt
    Using the AienTech/dossier repo, connect Gmail with the Google OAuth client <client ID placeholder> and open the application for <company name>. Return the prepared email and any employer reply with the drafted answer. Verify that nothing is sent until you confirm it, as the README states.

  • Build a GEO client package from one run

    Produce a diagnosis report, strategy, execution plan, ticket CSV, and acceptance sheet for a client from one project.

    View prompt
    Using the geolook repo at <repo path>, generate the full client delivery package for <client URL>. List each file produced, confirm the ticket CSV row count matches the open tickets on the Action page, and report any section that came out empty.

  • Approve agent browser actions from your iPhone

    Receive and approve browser actions on your iPhone with Face ID while away from the Mac.

    View prompt
    Using the Chrome Relay repo at aindeev/agent-chrome-relay, start a browser task on <site URL> that needs approval, and wait for the approval on the iPhone app. Expected output: the approval result. Verify that the request shows the page you expect before approving.

  • Write a machine page by hand from the template

    Copy the template and fill four sections yourself when no agent is available.

    View prompt
    Using the repo AirsupHQ/machine-skill, copy kit/template.html into a new page for <machine description> and fill its four sections by hand. The expected output is one HTML file that opens in a WebGL 2 browser. Verify that the page loads the kit runtime without errors in the browser console.

  • Turn a written requirement into a live window in the workspace

    Send a requirement to a conversation so the agent builds a result that auto-mounts into a locked custom window.

    View prompt
    Using Aisland-SJL/dsh-worktable, take the requirement <requirement-text> for project <project-name>, have the agent build it in a custom window, and report the result file path. Verify that the output mounts automatically into the locked custom window and that the file is under .dsh-worktable/.

  • Publish your reverse engineering work and list it in the index

    Open-source your tool and add it to the index so the next person finds it.

    View prompt
    For the repo <your repo URL>, check that it has a LICENSE file and a README naming the reverse engineered product. Then follow the contributing section of alexgaoth/awesome-reverse-engineered to prepare a listing entry. Verify the entry only uses facts from your README.

  • Turn a drawing into a step-by-step drawing lesson

    Create a captioned timelapse and step sheet that teaches how a picture is built.

    View prompt
    Using the anidoodle repo, rebuild <subject or drawing file> as a drawing lesson with a step sheet and a captioned timelapse. Return both files and confirm each step lists what to look for, how to do it and the common mistake.

  • Get commit messages from Claude with no chat wrapper

    Use the Attention-kind style so that when you ask for a message or commit, you get just that text.

    View prompt
    Using the repo alexgreensh/attention-span, install the attention-span plugin in Claude Code with Attention-kind as the Output style. Then ask Claude to write a commit message for <describe your change>. Expected output: only the commit message, with no wrapper text. Verify that the reply contains nothing except the message.

  • Ship a muted page loop or a scored launch video

    Choose the silent mp4 for autoplay or add a sound pass for a launch video.

    View prompt
    In the repo Alexwtlf/agentic-product-demo, render the composition <name> and confirm the silent mp4 exists in out/. If a launch video is needed, write beat files in scripts/beats/ and run `bash scripts/add-sfx.sh <name>`. Verify that out/<name>.mp4 is unchanged and that out/<name>-sound.mp4 exists.

  • Keep Claude working through the board when it wants to stop

    Set the routine so the agent checks the board again instead of ending its session early.

    View prompt
    In the project <project>, call working_agreement and report how many cards are waiting to be picked up and which card to take next. Expected output: those counts and the card name. Verify that the card is still in the first lane before you start it, and move it to in-progress when you claim it.

  • Route Claude model tiers to different models

    Send Opus, Sonnet, and Haiku requests to separate FCC models to balance cost and quality.

    View prompt
    In the repo Alishahryar1/free-claude-code, map the Opus, Sonnet, and Haiku tiers to different FCC models and start `fcc-claude`. Expected output: each tier shows its assigned model in the /model picker. Verify by running one short prompt on each tier and checking the server log.

  • Score log entries to find the ones that need a closer look

    Rank log entries by a Jev score so reviewers read the most suspicious ones first.

    View prompt
    Use the Jev Logs repo (https://github.com/reachjalil/jevlogs) to score the log entries in <path-to-log-file> and return them sorted by score. Verify that the highest-scored entries are listed first.

  • Design and review an HTTP/JSON API against API gates

    Use the optional old-coder-api skill to check compatibility, auth, idempotency, pagination, and rate limits.

    View prompt
    Using the old-coder-api skill, review the API change described in <spec-file-or-endpoint> for compatibility, authorization, idempotency, pagination, rate-limit, and operability. Output each gate as pass, fail, or unverified and list the resulting SPEC constraints and gauntlet checks.

  • Design a RAG pipeline from the retrieval lessons

    Use the RAG module to list the retrieval options before you build a pipeline.

    View prompt
    Read Module 9 in the README of amitshekhariitbhu/ai-engineering-course and draft a RAG design note for <target document set>. Output a list of chosen retrieval components with the matching lesson names, and verify that each component appears in the Module 9 topic list.

  • Estimate tokens, GPUs, and cost for an LLM feature

    Use the estimation and cost sections to size tokens, GPUs, and spend before launch.

    View prompt
    Using the repo amitshekhariitbhu/ai-system-design, follow the Back-of-the-envelope Estimation for AI section to estimate tokens, GPUs, and cost for <target>. Output a short table of the inputs, formulas, and results. Verify that every formula used appears in the README and that each assumption is stated.

  • Understand how LLM servers handle many users at once

    Read about continuous batching, streaming, and disaggregated serving to plan an LLM API.

    View prompt
    Using the amitshekhariitbhu/llm-inference-engineering repo, draft a one-page design note for an LLM API serving <number> concurrent users. Verify that the note explains continuous batching, streaming, and disaggregation using only the linked posts.

  • Run unattended computer use on a disposable VM or CI machine

    Set LCU approval to auto on a sandbox machine so the agent can run without a person at the keyboard.

    View prompt
    Using the amontlabs/lcu repo, configure LCU for unattended use on this disposable machine with `lcu setup --approval auto`. Run `lcu apps` and report the list of always-allowed apps. Verify that the list contains only apps the job needs.

  • Build Open Ghost installers from source for your platform

    Run the app from code and produce an installer for Windows, macOS or Linux.

    View prompt
    Clone https://github.com/ANDRETRIPOL/OpenGhost, run `npm ci`, then run the dist command that matches this operating system: `npm run dist` on Windows, `npm run dist:mac` on macOS or `npm run dist:linux` on Linux. Expected output: an installer in the dist folder whose name starts with OpenGhost. Verify that the file exists and that `npm start` launches the app.

  • Generate a Frida verification hook that fixes its own errors

    Create a Frida hook script for an APK and let the agent retry failed runs up to three times.

    View prompt
    Using the Seep Reverse Lab workspace, generate a Frida hook for <class-name> in <path-to-apk> with seep_apk_gen_hook and run it on the connected device. Expected output: hook_verify.js and the captured stdout. Verify that the run stops after three attempts if it does not succeed.

  • Install the OpenCode desktop app for daily use

    Download the beta desktop app for your platform and open it without using a terminal.

    View prompt
    Install the OpenCode desktop app from opencode.ai/download for <platform> in the anomalyco/opencode project. Expected output: the app launches and shows its main window. Verify that the installed version matches the download you chose for your architecture (Apple Silicon or Intel on macOS).

  • Flag risky behavior in AI traces with Span-01

    Label each AI trace for behaviors you define, such as prompt injection or agent loops.

    View prompt
    Using the Span-01 entry in github.com/AnotiaWang/awesome-decision-models, classify the traces in <traces-folder> for prompt injection and agent loops through the OpenRouter route the README links. Expected output: one present, absent, or not observable value per behavior per trace. Verify by reading three traces marked present and confirming the behavior is actually there.

  • Set up an experiment with the bundled agent skill template

    Use the skills/ template so a coding agent interviews you and drives the experiment setup.

    View prompt
    Using the AntOmniEvo repo (ant-research/AntOmniEvo), hand its skills/eddy-antomnievo-experiment skill to the coding agent and set up an experiment for <target-repo> with dataset <dataset> and metric <metric>. Expected output: a written entry script and a launched run. Verify that the agent asked for the repo, dataset and metric before writing any files.

  • Run the Ldraw Nova web app with Docker

    Start the browser app with 3D and VR views on localhost using Docker Compose.

    View prompt
    Clone the ldraw-nova and ldraw-nova-docker repositories at tag v0.6.0 side by side, then run docker compose build and docker compose up -d inside ldraw-nova-docker. Report the local URL and confirm that http://localhost:8765 responds before finishing.

  • Change a published plugin's label without breaking installs

    Update displayName or add a renames entry so existing users keep working.

    View prompt
    In the anthropics/claude-plugins-official repo, update the marketplace entry for <plugin-name> so its UI label changes to <new-label> by setting displayName, without changing name. Output the diff. Verify that the name field is unchanged.

  • Automate browser tasks with Claude and Playwright

    Let Claude navigate websites, read page content and fill forms through a Playwright-backed browser tool.

    View prompt
    Work in the anthropics/claude-quickstarts repository. Open the browser-use-demo quickstart, follow its README to install dependencies, set the Claude API key and start the demo. Give it one read-only task on a page you control and report whether it extracted the expected content.

  • Search Poly Haven or Sketchfab and import a chosen asset

    Let the assistant find a matching asset, ask before importing, and follow its license.

    View prompt
    Using the mcp-for-blender-pro add-on, search Poly Haven, Sketchfab or Poly Pizza for <asset description> with the search_assets tool. Ask for approval before calling import_asset. Return the asset name, source and license for each result. Verify the license permits your intended use before importing.

  • Run a multi-step scene edit with a manager, workers and reviewers

    Use a team chain so one agent plans, others edit and reviewers approve each change in order.

    View prompt
    Configure a Team chain in the mcp-for-blender-pro Studio window to apply <list of scene changes> to <scene name>, with a manager, workers and reviewers. Expected output: each change assigned, performed and approved in order, with findings on the task board. Verify the final scene by listing objects and checking that every reviewed task was marked approved.

  • Keep the codebase index current as the agent changes code

    Let the MCP workflow flag changed files and have the agent update their entries after each verified task.

    View prompt
    In the repo <project-path>, make the requested change, run the tests, then update the AOCI entries for every changed managed file so the index is aligned. Report the list of updated entries and confirm the index is aligned.

  • Run the agent in a Docker container from a local build

    Build the checkout into a container with Compose and run the agent inside it.

    View prompt
    Using the FrontierAgent repo at <repo path>, build the checkout with Docker Compose using compose.yaml and compose.dev.yaml, then run the agent service. The expected output is a running agent session inside the container. Verify that the container starts, reads the endpoint values from .env, and that the run directory is created.

  • Plan which checkout screens push, sheet, or lock

    Have an agent decide the navigation for a checkout flow so users cannot return to the paywall after paying.

    View prompt
    Using the appllama/appllama-skills repo, map the navigation for the <checkout flow name> in an Expo / React Native app, labeling each screen as push, sheet, or one-way. Output the navigation map and transition code, and verify in the simulator that the back action cannot return to the paywall after payment.

  • Run GLM-5.3-Flash on a rented Google Cloud TPU VM

    Use the gcp/ guide and scripts to serve GLM-5.3-Flash without the Kaggle queue or time cap.

    View prompt
    In the ARahim3/kaggle-tpu-lab repo, follow the gcp/ guide to set up a v5litepod-8 or v6e-8 TPU VM, run the environment, datasets and run scripts, and serve GLM-5.3-Flash. Expected output: a running server on the TPU VM. Verify the server responds to one test request before reporting success.

  • Add a plugin lifecycle to a Rust application

    Run plugins in a Rust program that starts once dependencies are ready and cleans up on stop.

    View prompt
    Using the repo arcships/rutis, add the rutis and tokio crates to <target> with `cargo add rutis` and `cargo add tokio --features full`, then run `cargo run -p rutis --example quickstart` from a clone. Expected output: the listener printing a greeting, then printing a new greeting after the provider is replaced. Verify that the listener restarts without any change to its own code.

  • Find what is actually broken on a screen or flow

    Get a ranked review of a screen, including states a screenshot misses.

    View prompt
    Using the ui-review skill from the arla6ka/design.how repo, review <target screen or flow> in this app. Expected output: a ranked list of broken items, including states a screenshot would miss. Verify that each item names a specific state or element you can reproduce.

  • Send photos and PDFs to an agent from your phone

    Upload files over P2P and insert their workspace paths into the agent draft.

    View prompt
    In the arronKler/pairfob repo, open README.md and quote the sentence that describes how files are handed to the agent. Output that quote and the list of file types the README names. Verify the quote matches the README exactly.

  • Turn a playlist into study notes

    Read every video in a playlist and produce notes per lecture.

    View prompt
    Using the youtube-skills repo, list every video in the playlist <playlist URL>, fetch each transcript, and write one set of study notes per video with timestamps. Verify that the number of notes equals the number of videos returned.

  • Benchmark Qwen on Splash on an Apple Silicon Mac

    Run the pinned Splash recipe on an M3 or newer Mac and get a verified, reproducible result.

    View prompt
    Using the agentperf-local repo from ArtificialAnalysis, run `agentperf-local managed-run` with --profile-id qwen38-27b-splash-dflash and --framework splash, writing to results/<name>. Expect summary.json in that directory. Verify that the recipe ran the exact policy and that the KV cache was eight-bit before reporting numbers.

  • Make diagrams match your brand from your site or CSS

    Point See Code at your website, stylesheet or colour list so diagrams use your palette in light and dark modes.

    View prompt
    Use the SeeCode skill from the Aryanutkarsh/SeeCode repo to learn the brand palette from <your website URL or CSS path> and then draw <describe the diagram> with it. Expected output: a diagram in the brand palette with light and dark versions. Verify that the palette shown before saving matches the brand and that label text stays readable.

  • Evolve skills on a custom task set you write

    Write tasks.json with auto-graded checks and run the loop on your own agent work.

    View prompt
    In the ashutoshsinghpr7/wikiskill repo, add my tasks.json with train and val splits and at least one task per grader type I use. Run `wikiskill evolve --iters 2` and report the baseline score and any rejected proposals. Verify that every task has a grader and that missing deliverables score 0 rather than crashing.

  • Let the agent file durable facts when a session ends

    Turn on auto-summarize so a background model saves new durable facts after each session.

    View prompt
    Edit the cordis.patch.yml for the DeepSeek Harness profile demo so the dsh-auto-memory config sets autoSummarize to true and autoSummarizeMaxMemories to 5. Expected output: after a session ends, new memory files appear under the memory folder. Verify that the new files contain durable facts only and that MEMORY.md lists them.

  • Replay a past session and get a recap

    Scrub through an earlier session to see who worked when and get a recap of tool calls and files changed.

    View prompt
    In the repo Atoll92/agent-standup, open a past Claude Code session in replay and produce its recap. Report the agents, tool calls, commands, files changed and busiest agent. Verify the files-changed count against the session's own record before reporting it.

  • Find agent and MCP configs inside project folders

    Add project directories to the scan to catch project-level agent and MCP configuration.

    View prompt
    Run `npx geiger-scan --path <project path>` for each project folder <project path> and return the project-level agent and MCP findings with their evidence paths. Verify that git hooks are reported only for the directories you passed in.

  • Serve Atria Dawn on your own hardware with SGLang or vLLM

    Run the model locally using a supported SGLang or vLLM version.

    View prompt
    Using the atria-asi/Atria-Dawn README, set up a local inference server for Atria Dawn with SGLang v0.5.13.post1 or later, or vLLM v0.23.0 or later, following the linked guide. Choose a model from the download table that is currently available. Expected output: a running local server that answers one test request. Verify the framework version before loading the model.

  • Wrap your team's toolchain as a harness

    Copy the hello-world example, check it, and install it as your own harness.

    View prompt
    In the openharness repo, copy store/examples/hello-world to ../<harness-name>, update its harness.json and AGENTS.md for <team-toolchain>, then run `harness dsh check ../<harness-name>`. Report the check result and confirm the harness installs with `harness dsh install ../<harness-name> --link`.

  • Share Claude Code memory across machines on Postgres

    Move Claude DB from local SQLite to a shared Postgres or MongoDB database.

    View prompt
    In the repo <repo-path>, switch claude-db to the database <pg-or-mongodb> and run claude-db doctor. Expected output is a passing setup check and a status line showing the chosen database. Verify that claude-db status reports the same memory count on a second machine after one chat is recorded.

  • Use one project memory across Cursor and Codex

    Point Cursor or Codex at the same JEVMEM.md so the agent reads the same saved lines.

    View prompt
    In the repo at <project-folder>, run `jevmem init --tool codex` and then confirm that jevmem watch starts without errors. Expected output: a running watch process and no setup errors. Verify that a decision made in a Codex chat appears as a line in JEVMEM.md.

  • Run jev on OSWorld desktop tasks to compare results

    Set up OSWorld beside jev and run one desktop task to see how the agent performs on a benchmark.

    View prompt
    In the typesafe-computer-use repo, run `scripts/osworld setup` and then `scripts/osworld run-jev chrome/  --ocr rapidocr` on a Linux host with KVM. Report the task result and any error from the setup. Verify that the run finished on the chrome/ task before comparing it to the GPT agent result.

  • Connect any MCP client to the code graph

    Add one config entry so an MCP-capable agent can query the graph.

    View prompt
    Using the axiomcode MCP server in <repo>, find the call path to <target> and list each hop with file and line. Expect the same hops that `axiomcode path` prints in the shell. Verify that both outputs match before reporting.

  • Audit an existing codebase with a triaged scorecard

    Onboard a legacy repository and get a triaged scorecard of its quality before an agent edits it.

    View prompt
    Run the procoder audit command in the repository at <repo-path> and summarize the triaged scorecard. Pick the highest-priority blocking item and propose a fix without editing files yet. Verify that the audit output reports which mode it ran in.

  • Reproduce the byte_nll_v1 evaluation numbers

    Rerun the byte-level NLL protocol on the test split and compare against the reported results.

    View prompt
    In the repo https://github.com/BaruqueRodrigues/llm-legislativo, run the byte_nll_v1 evaluation in src/legislm/evaluation/ on the test split and report nats per byte for the whole set and for the Câmara and Senado subsets. Compare with the README values 0,7297 and 0,8817 and 0,7049. Verify the document and byte counts match 71.069 documents and 482 million bytes.

  • Check beat sync and mix balance of a motion video

    Run the bundled Python checks on a project to find splice drift and a music-to-speech imbalance.

    View prompt
    Using the motion-video skill from bestagentkits/motion-video-skill, run verify-arrangement.py and measure-mix-balance.py on the project at <project-path> and report each music segment's splice lag and the music-to-speech level difference. Expected output is a short pass or fail report. Verify that every segment is within ±2 ms of its target beat and that music is about 4 to 6 dB under speech.

  • Package book-production services for clients

    Turn the same toolkit into agreed deliverables for freelance book and design clients.

    View prompt
    Use the Beyondwords skill from beyondtahir/beyondwords to produce a <service> deliverable for the client <client name> under the scope <scope summary>. Return the research brief, the draft or design and the EPUB or PDF output. Verify that the client's material and approvals are kept separate from other projects.

  • Trace React Native calls into native Swift, Kotlin or Objective-C

    Find the native method behind a NativeModules call in a React Native or Expo app.

    View prompt
    Using the bgts-context-engine repository, index the React Native app at <target repo path>, then run bce context with the task <question about a NativeModules call>. Expected output: a ranked answer that includes the native Objective-C, Swift or Kotlin method. Verify that the native method is linked from the TypeScript call site.

  • Turn speech into translated subtitles

    Use Index-Echo S2TT to produce subtitles from speech in zh to en, ja, or es.

    View prompt
    Use the repo at https://github.com/bilibili/Index-Translate. Follow inference/echo-s2tt/README.md to translate the speech file at <audio_path> from zh to <target_language> and return the subtitle output. Verify that the target language is one of en, ja, or es and that subtitles follow the speech order.

  • Let Claude Code or Codex make and tweak 3D assets

    Connect AssetFurnace as an MCP tool so your coding agent makes, checks and adjusts 3D assets locally.

    View prompt
    Using the AssetFurnace MCP server in the repo at <install folder>, make a 3D model of <subject>, check the run status, and open the result in the studio. Verify that the agent asks before downloading any model weights and that the output file exists on disk.

  • Check whether compacting at 200K actually saved money

    Apply the change, wait several days, then compare cost per prompt and each trade-off to the days before.

    View prompt
    In the optimaizr repo, after context compaction has been applied for several days, run `optimaizr results` on this machine and report cost per prompt before and after. Verify that every row that got worse is marked as a trade-off before you draw a conclusion.

  • Define custom Agents with your own models and tools

    Write Agent definitions that use your own models, tools, skills, and workflow.

    View prompt
    Using the pi-herdsman repo and its Agent definitions guide, create a custom Agent named <agent name> that uses <model or tool list> and delegate <task> to it in <project path>. Expected output: a completed result from the custom Agent. Verify that /agents shows the custom Agent running under the Lead session.

  • Let a coding agent build screens from BoardUI through MCP

    Connect the BoardUI MCP server so your agent can browse the catalog and install components.

    View prompt
    Using the BoardUI MCP server from the repo BoardUI/boardui, add the <component-names> components to my project at <project-path>. Expected output: installed component source and a page that uses them with BoardUI tokens. Verify that the AGENTS.md rules were followed and the app builds.

  • Make an encrypted backup of your WeChat history

    Create a copy of your chat history protected by a 24-word recovery phrase, readable later without WeChat.

    View prompt
    Following docs/RECOVERABLE_SNAPSHOTS.md in the repo bojieli/greenbubbles, help me create an encrypted snapshot of my WeChat history. Report the snapshot location and confirm the 24-word recovery phrase was shown. Verify that the recovery phrase is not written to any file or sent in a prompt.

  • Ship a PartMode CAD fix that passes the contributor gate

    Run the focused gate and the affected smoke checks before submitting a behavior change.

    View prompt
    In the BOMWiki/partmode repository, make the change described in issue <issue-number> within its accepted boundary, run `npm run ci:gate`, and run the affected smoke checks listed in the issue. Report the gate result and the exact kernel or export evidence, and verify that the gate exits with status 0 before opening a pull request.

  • Audit a draft's prose and bibliography with the skills

    Install the skills repository so an agent can check claims, quoted numbers, and bibliography entries.

    View prompt
    Using the BootLoops skills repository at ../skills, apply the prose-editing and bibliography-verification skills to my draft <path to draft>. Report each unsupported claim, each quoted number that cannot be traced to a source, and each bibliography entry that fails verification. Verify that you did not add any claim that is absent from the draft.

  • Test a BotBus client against the public wire fixtures

    Run the Swift and TypeScript checks and the sealed fixtures to confirm a client decodes the protocol correctly.

    View prompt
    Clone botbus-io/botbus-protocol, run `swift test` and `npm test`, and report the pass or fail count for each. Then decode every file in protocol-fixtures/ with <your client decoder> and list any fixture it fails to parse.

  • Automate browser steps that survive page redesigns

    Use claw-browser-anchor to target stable DOM selectors and ARIA roles instead of screen coordinates.

    View prompt
    Using the genspark-claw repo at github.com/breakstageaxe61/genspark-claw, install the claw-browser-anchor skill into the workspace and use it to automate this browser task: <task-description>. Expected output: a set of steps that target DOM selectors or ARIA roles, each followed by a verification. Verify that the final page state matches <expected-state> before reporting success.

  • Approve guards for mistakes Claude keeps repeating

    Review drafted tool-call checks that remind or block Claude, and apply only the ones you approve.

    View prompt
    With ctx-handoff-mod installed in Claude Code, open `/handoff panel` for <project path> and review any drafted guards. Expected output: a list of guards with approve or decline choices. Verify that nothing is applied until you approve it.

  • Approve scenes on a live storyboard before rendering

    Review takes, prompts, cost, and quality scores in Backlot before the final render starts.

    View prompt
    In the OpenMontage repo at <repo-path>, start a production for <topic] and open its Backlot board. Stop at the asset approval gate and report the per-asset costs. Verify that no final render has started until approval is given.

  • Record CPU, memory, and FPS and compare two runs

    Capture an interaction on a device and ask Codex to compare it with an earlier run.

    View prompt
    Using the callstackincubator/codex-mobile-dev-plugin Mobile Dev plugin, record CPU and memory on <device name> during <interaction> before and after my change in <project path>, then compare the two runs. Expected output: a comparison of CPU, memory, and Display FPS between the runs. Verify both recordings cover the same interaction length before drawing a conclusion.

  • Decide between a fixed pipeline and an agent using cost and latency data

    Compare a fixed pipeline with an agent loop on cost, latency, and quality before you pick one.

    View prompt
    Using the repo calmrocks/ai-engineer-notebooks, build the agent loop from 05-agents/01-agent-loop-from-scratch.ipynb and a fixed pipeline for <placeholder task>. Expected output: a table comparing calls per task, latency, and quality for each. Verify that both versions were scored on the same set of inputs.

  • Keep a local notebook of a research question

    Store prompts, results and observations for one question in Lab → Studies.

    View prompt
    In the canivel/dynolab repo, read docs/research-notebooks.md and create a study for the question <question>. Expected output: a saved study with prompts, results and observations in Lab → Studies. Verify that any token-limited or incomplete run is shown as incomplete, not as an answer.

  • Connect your own app to a local model API

    Run the Slotstream server and point an Ollama or OpenAI client at it.

    View prompt
    In the carloslfu/slotstream repo, run `slotstream serve --prefix-cache-dir <folder>` and send one OpenAI-compatible chat request to the local address printed at startup. Expected output: a JSON chat response from the local model. Verify that the response contains generated text and that the server log shows the request.

  • Pressure-test a business decision before committing

    Use the CEO advisor skill to surface the assumption a plan rests on and the case against it.

    View prompt
    Using the cbrock84/headcount repo, load the executive:ceo-advisor skill and pressure-test the plan in <plan-file>. Expected output: the main assumption, the case against the plan, and what would have to be true. Verify that the named assumption is actually stated or implied in the plan file.

  • Rewrite extracted text files with look-alikes folded

    Replace look-alike glyphs in your text files directly, after confirming what will change.

    View prompt
    Using the cjkfold repo, install it with pip install cjkfold, back up <path-to-text-file>, then run `cjkfold fold -w <path-to-text-file>`. Report the number of characters that changed by comparing the file before and after. Verify with `cjkfold check <path-to-text-file>` that it exits with code 0.

  • Grade how obstructed each package is in a photo

    Score every detected package in a warehouse image against a rubric you define.

    View prompt
    In the JEV_sees repo at <repo path>, write and run a Python script that calls Sees().for_each("package").score(...) on <photo path> with the rubric 0: clear, 1: partly obstructed, 2: heavily obstructed. Expect one score per package in output.json; verify that every score is one of the three rubric levels.

  • See herb and ore spawns on your world map

    Use two slash commands to show gathering nodes filtered by your skill.

    View prompt
    In the wow-ai repo, with WoW AI enabled in game, run /wow-ai map herb and /wow-ai map ore and check the world map. Expected output: spawn markers for the chosen gathering type. Verify that the markers match your gathering skill before reporting results.

  • Export a folded paper as one page that opens without a server

    Export a paper's levels as a single HTML file to share or keep offline.

    View prompt
    Using the TextFold repo at github.com/chenxiachan/textfold, run `python3 -m textfold export <arxiv-id>` for the paper with ID <arxiv-id>. Expected output: an HTML file with the five levels of that paper. Verify that the file opens in a browser with no server running and that the license note under the title is still shown.

  • Check exit IP, timezone and locale before a site test

    Confirm a proxy's country, timezone and datacenter status before a geo-specific test.

    View prompt
    Using the repo chienbm98/foxprofile, create or update the profile <profile-name> with the proxy <proxy-url>, timezone <IANA-zone> and locale <locale>, then run Check IP. Return the exit IP and any warnings. Verify that the timezone and locale fields hold the values you set and are not blank.

  • Find a past image by what it shows or what you said about it

    Search the panel by description or your earlier comment, then check the right image before sending.

    View prompt
    Using the repo chipfighter/context-attachment-manager, open the Context Assets panel for the task <task name> and search for <phrase from memory>. Report the ID, turn, and source of the matching image, then check Send on it and confirm the next request includes that image.

  • Install a third-party Harness plugin from GitHub

    Add a Harness plugin from a GitHub repo through Desktop, with automatic rollback if startup fails.

    View prompt
    Using the chokwinlee/deepseek-harness-desktop repo, help me install the Harness plugin from github:<owner>/<repo> through DSH Desktop on macOS. Expected output: the plugin listed in Plugins and Harness running after restart. Verify that you have reviewed the plugin source and publisher before you confirm the install.

  • Self-host actors on a Celld fleet

    Deploy the same Worker entrypoint to your own Celld fleet with an S3 bucket.

    View prompt
    In the repo clavia-labs/tardigrade, follow docs/platforms/celld.mdx to write a celld.jsonc for <fleet-name>, then run `celld deploy --config celld.jsonc --bucket s3://<bucket-name>`. Expected output: a deployment summary from celld. Verify that the same Worker entrypoint from createActorWorker is used and that the bucket credentials are read from the environment, not committed to the repo.

  • Add typed routing to a LangChain pipeline

    Insert a Jev classifier Runnable that routes requests and checks risky tool calls.

    View prompt
    In the langchain repository at github.com/langchain-ai/langchain, wire the TypeSafeClassifier Runnable to route <request type> into the fixed routes <route list>. Report the route chosen for each of twenty labeled requests. Verify that every risky tool call is blocked or flagged by the middleware.

  • Find the largest model your PS5 can run

    Compare suggested models and watch console load to choose one that fits memory and speed.

    View prompt
    Using the cobanov/PS5LM repo, list the models in the Suggested section for a PS5 at <PS5-IP> and compare them with the README speed table. Expected output is one recommended model and its measured speed, and verify that it fits the free memory the planner reports.

  • Push an agent branch and open a PR or MR

    Let a run push a branch and open a pull or merge request through gh, glab, or SSH.

    View prompt
    Using the Grasp repo (cocofhu/grasp), run a delivery workflow for <repository URL> that pushes a branch and opens a PR after human confirmation. Verify the branch name and PR link, and report both.

  • Give every teammate the same rule enforcement through the repo

    Install Abide into the project so the hooks travel with the checkout instead of each person's machine.

    View prompt
    In the repo <repo-path>, install Abide into the project with `init --project` for the agent in use, then list the files that were created or changed and confirm which ones should be committed. Report any file that is outside .abide/ or the agent's project extension path.

  • Capture an agent's system prompt for each model

    Record the prompt a harness assembles for a given model, with the local machine details removed.

    View prompt
    Use the OrcaReplay repo (Continuum-AI-Corp/OrcaReplay) to capture the system prompt for the agent claude with the model <model-name> by running `node capture/capture.mjs claude --model <model-name>`. Report the file path where the sanitised prompt was saved. Verify that the saved prompt contains no local machine paths.

  • Review agent failures and approve proposed fixes

    Inspect execution evidence in Findings and ask Composer for a reviewed change.

    View prompt
    In the agent-foundation Service Console, open Findings and list the diagnoses with status for <agent-name>. Pick one, summarize its cited evidence, and confirm that no change was published before you review it.

  • Deploy Open Bot as one image for a small team

    Run the published Docker image with your .env and an embedded database, then lock down sign-in before sharing it.

    View prompt
    For the OpenBot repository at <repo-path>, deploy the image ghcr.io/copilotkit/openbot:latest with the README's docker run command and the local .env file. Report whether the container answers on port 3001 and confirm that sign-in is configured before the URL is shared.

  • Build Hermes Office from source for an unsupported platform

    Compile the suite yourself when no published build exists for Intel Mac, Windows, or Linux.

    View prompt
    Clone github.com/criptogus/HermesOffice, follow the Development section of its README to build the app for <platform>, and report the build command that succeeded and the path of the built shell. Verify that the built shell opens <path to a test .docx>.

  • Review agent diffs and PR checks beside the session

    Inspect diffs, stage, commit, and follow PR checks next to the agent that wrote the code.

    View prompt
    In the diri repo at github.com/cristicretu/diri, open the session <target-session>, list the files changed in its diff, and confirm the staged changes match what I approved. Output the file list and the commit hash after commit.

  • Add documents to a wiki from a Python script

    Import the Wiki class and file text or files into a wiki from your own code.

    View prompt
    Write a Python script that imports Wiki from llmw2, points it at ./wiki, and calls ingest on each file in <folder>. Expected output: one result per file with the note and token usage. Verify that each returned note appears as a Markdown file under ./wiki.

  • Resume a past agent session and export it to Markdown

    Reopen a saved session with /resume or star -r, then save it as Markdown with /export.

    View prompt
    Using the cryer/star-cli repo, run `star -r` in <project-dir>, select the session for <task>, then run `/export`. Report the exported file path and verify that the file opens as Markdown.

  • Build a support agent that works your ticket system

    Wire your own ticketing tools into a WhatsApp agent so customers get fixes, not just an email form.

    View prompt
    In the csr1010/wappy-kit repo, scaffold a project with `npm create @wappy_ai/agent` into ./<project-dir>, then add one tool that calls a ticketing API at <ticketing-api-url>. Expected output: a tool that returns a ticket status to the agent. Verify that the test call uses a sandbox ticket account and not production data.

  • Let an agent work inside your own logged-in Chrome

    An agent uses your daily Chrome or Edge session through the extension bridge.

    View prompt
    Using the axuse MCP server with the extension backend, open <site URL> in the user's logged-in Chrome session and report the account name or main heading shown on the page. Confirm the bridge is connected with the bridge verify command before acting.

  • Plan the port of a GitHub App to the Origin API

    Use origin-apps to map an existing GitHub App onto the Origin API before writing code.

    View prompt
    Using the origin-apps plugin from the cursor/plugins repo, fetch the live Origin API spec and plan the port of the GitHub App at <app-repo-path>. Output a port plan that maps credentials, scopes, webhooks, paging, and errors. Verify that the plan cites the live spec and lists any unmapped items.

  • Compare what an agent was asked, said, and did

    Record a v2 coding-agent run and run analysis that compares the request, the model's account, and what ran.

    View prompt
    In the project at <project-path>, run `pip install tracekit-ai` and `tracekit init --dev --v2`, complete one short coding-agent session, then run `tracekit analyze --v2`. Expect findings comparing requested, reported, and executed actions. Verify that the integrity status from `tracekit last` is reported separately from the findings.

  • Get a delivery report of what was checked and what was not

    Receive agent-written work with a clear list of verified, reused, and unchecked items.

    View prompt
    Using the Da7-Tech/SureForge skill, freeze the candidate for <deliverable path>, inspect every agreed unit on that exact version, and report what was verified, what was reused, and what was not checked. Expected output: a delivery gate result and a coverage ledger. Verify that every item in the report is backed by evidence or marked as not checked.

  • Resume a long task in a fresh window without a full log dump

    Prepare a bounded resume packet so an agent can continue a long task from its references.

    View prompt
    Using the Squadra repo at https://github.com/dagoSte/squadra, prepare a resume packet for task <task ID> in the project at <project path>. Expected output: a read-only packet listing the task, scope and proof references. Verify that the packet contains references and not full conversation or log text.

  • Run a bundled RSI method on a prepared experiment

    Prepare, check, run, and independently test a Meta-Harness, RRSI, AHE, or HarnessX workflow.

    View prompt
    In the rsi_eval repo, prepare a <method> experiment at runs/<experiment-name> using profile.json, then run method check, run, and test in that order. Report the artifact selected by the method and the test output. Verify that the experiment directory contains the frozen configuration and seed.

  • Export a handwriting web font with CSS for a site

    Generate WOFF, WOFF2, and an @font-face snippet to use your handwriting on a website.

    View prompt
    Use the draw-your-font repo to build a font from <photo-path> with --formats ttf,woff,woff2,css and save the outputs to <site-assets-dir>. Expected output is WOFF, WOFF2, and a CSS @font-face snippet. Verify that the CSS references both the WOFF2 and WOFF files.

  • Resume an interrupted run and export its outputs

    Pick up a stopped training run from its checkpoint and export the adapter and configs for hand-off.

    View prompt
    In the miniverl repo (DaoyuanLi2816/mini-verl), resume the run with ID <run-id> from its latest checkpoint and export its adapter and configs to <export-dir>. Report the export paths and the remaining setup listed in the hand-off report. Verify that the resumed run continues from the saved step.

  • Read mixed-language and handwritten scans in one run

    OCR scans in many scripts and handwriting, with a CJK-only or RTL-only fallback when needed.

    View prompt
    Using the repo datalab-to/indra, install indra-ocr and run `indra-ocr <file>.pdf --mode ocr --timings` on <file>.pdf. Expected output: markdown with the text in each script and per-page timings on stderr. Verify the text for each script against the source page, since handwriting accuracy is limited.

  • Measure BPB and QA scores for an EBFM checkpoint

    Run position-wise BPB and QA evaluation on a published model and collect results.

    View prompt
    In the datamllab/OpenEBFM repo, run runs/eval.sh for BPB and runs/qa.sh for QA on the checkpoint <hf_model_id>, using the local snapshot directory for the tokenizer path. Report the results/ paths and confirm token_bytes.pt was found in the snapshot.

  • Map RadixAttention from the course to SGLang source

    Compare the Chapter 8 prefix caching walkthrough with Part III caching chapters and the real SGLang code.

    View prompt
    Using https://github.com/datawhalechina/zero-to-sglang, read the RadixAttention chapter and the Hierarchical Caching chapter, then find the matching functions in a local clone of https://github.com/sgl-project/sglang at <path>. Expected output: a table of course concept to source location. Verify each file path exists in the clone before listing it.

  • Connect the Cloudroom desktop app to your core

    Point the Mac desktop app at your own core using a URL and token, with no account.

    View prompt
    Using the cloudroom-core setup guide in docs/setup.md, connect the Cloudroom desktop app on <mac-host> to the core at <core-url> with the token <token>. Expected output: the app lists the core as connected. Verify that an agent started from the app appears in the core's saved history.

  • Switch between several Claude accounts in one click

    Use more than one Claude account in the same app without logging out and back in.

    View prompt
    In the Cloudroom app from the cloudroom-gui repo, add two Claude accounts and switch between them. Expected output: a thread running on each account, with the account name shown for each. Verify that the account shown matches the one you selected before starting work.

  • Export a dashboard as HTML, PDF, or PNG

    Render a board to a static file that you can send to people who do not run the CLI.

    View prompt
    In the dbt-charts repo, render the board at <placeholder> to PDF with `dct render <placeholder> --format pdf` and report the output file path. Verify that the file opens and shows the expected charts.

  • Preview what enforcement would change on live agent traffic

    Run the gateway in shadow mode and read the report of what enforcement would have held or refused.

    View prompt
    Using the decionis/agent-safe-pipeline repository, install AgentSafe and run it in shadow mode in front of <your-api-url>. After the agent has run its normal tasks, run `agentsafe status` and summarize what enforcement would have held or refused, by action. Verify that the shadow report reflects requests the agent actually sent before recommending enforcement.

  • Add extra runner machines to a self-hosted FDE Gym site

    Attach more machines to run cases, on any network that reaches the site.

    View prompt
    In the fde-gym repository at <path>, read the runner section of docs/self-hosting.md and list the network and setup requirements for an extra runner. Output a numbered checklist. Verify each item is stated in that document before adding it.

  • Tune the glass thickness, tint and radius with the Create page

    Adjust theme dials on the Create page and take the few lines of CSS into your project.

    View prompt
    Open the Create page of the Solid Glass site, set the dials to <chosen-values>, copy the generated CSS, and add it to <stylesheet-path> after the solid-glass.css import. Report the variables changed and confirm the project still builds.

  • Push timed observations from a system into a dated graph

    Send each observation with its timestamp so the base can answer where something was at a time and where it is now.

    View prompt
    Using the Utopia repo at <repo path>, push the timed observations in <file> for object <object id> through the extraction contract in docs/walkthrough.md. Expected output: the value at <time> and the current value, each with its observation. Verify that the earlier value was closed, not overwritten, when the later observation arrived.

  • Write a plugin for the everything-is-a-plugin harness

    Build a plugin on the harness architecture and publish it with the dsh-plugin topic.

    View prompt
    Using docs/architecture.md and docs/development.md in the deepseek-harness repository, draft a plugin in <target folder> that <describe capability>. Run `pnpm run build` in the base repo and report whether the plugin loads without errors.

  • Generate a workflow with Claude Code or Pi instead of Codex

    Switch the Agent runtime used to generate a workflow without changing the rest of the process.

    View prompt
    Using the deer-workflow repository (deerwork-ai/deer-workflow), generate a Workflow for <target job description> with the --agent claude option and save it to workflow.ts. Expected output: a runnable TypeScript module. Verify that the file runs with a sample input and that the phases match the job.

  • Package an agent delivery case for payer review

    Initialize, inspect, verify, and export a Verified Agent Delivery case as a third-party review package.

    View prompt
    Using https://github.com/dengyier/OpenWorkProof, run `owp delivery-case init <CASE_DIR>`, then `owp delivery-case inspect <CASE_DIR>` and `owp delivery-case verify <CASE_DIR>`, and export with `owp delivery-case export <CASE_DIR> --output-directory <OUTPUT_DIR>`. Report the derived status. Verify that the status comes from the Surface, Acceptance, and Settlement evidence and not from a pre-written conclusion file.

  • Export a layered PSD from a local ComfyUI edit

    Run inpainting on your own ComfyUI and export the result as a PSD with layers and masks.

    View prompt
    Using the Scumble repo at https://github.com/DenRakEiw/scumble and its ComfyUI-InpaintCanvas node pack, run an inpainting edit on <path to picture> against my local ComfyUI at <server address> and export a PSD to <output path>. Expected output: a PSD file with one layer per edit. Verify that the PSD opens with layers and masks intact.

  • Adapt the staged review workflow for your team

    Change the review layers or policy in code and confirm the dependency checks still pass.

    View prompt
    In the jev-review repo, change one threshold in src/domain/config.ts, then run `npm run check`. Report whether typecheck, the dependency check, and the dashboard syntax check pass. Verify that no import now points upward from a lower layer.

  • Send your own app's Anthropic API calls through the pool

    Point any Messages API client at the local daemon so its requests use the pooled accounts.

    View prompt
    Using the DevDock-AI/claude-unlimited repo, set ANTHROPIC_BASE_URL=http://127.0.0.1:4317 and run <app-command> against the Messages API. Expected output: the app gets normal responses. Verify that the request appears in the dashboard activity log at http://127.0.0.1:4317/.

  • Let a workspace reach private services through abox-link

    Pair abox-link so an agent can use allowlisted repositories, databases, or services on your network.

    View prompt
    Using the agentbox repo at github.com/devilcoolyue/agentbox, pair abox-link on <server-host> and add only <service-address> to the allowlist. Ask the workspace agent to connect to that service and report the response status. Confirm that a non-listed address is refused.

  • Move your profiles to a new computer

    Install the app on a new machine and migrate cookies, profiles, or the whole workspace locally.

    View prompt
    Using the repo DFarm6/Prism-Browser-Community, list which data the README says stays on the device for <profile name>. Expected output: a short list of local data types. Verify the release checksum before installing on the new computer.

  • Review skill adoption and find coverage gaps

    Check which skills are loaded, where descriptions are weak, and where the library lacks coverage.

    View prompt
    Using the Dicklesworthstone/skillranker repo, run `sr stats --since 7d --by-skill`, `sr doctor --descriptions`, and `sr gaps`. Expected output: per-skill adoption counts, description quality notes, and suspected coverage gaps. Verify that the report labels adoption as observation and does not present it as proof of usefulness.

  • Build and test Uni Switch from source

    Install dependencies, run the checks and build the desktop app from the repository.

    View prompt
    Clone github.com/dieqiyun/uni-switch and run the frontend typecheck and tests with pnpm. Expected output: typecheck and test results with pass or fail counts. Verify that the lockfile install completed with --frozen-lockfile before running the tests.

  • Build release binaries for six OS and CPU targets

    Cross-compile archives for Linux, macOS and Windows on x86-64 and ARM64 from one machine.

    View prompt
    Using the repo DingoOz/llm-visuals, run `./scripts/cross-build.sh` from the repo root. Expected output: archives for each target this host can link, written to dist/. Verify the count of archives matches the number of targets the script reports as buildable.

  • Gate a release check behind your own approval

    Run the release-check durable job so the agent gathers evidence and waits for you before it publishes.

    View prompt
    In the Durable Pi repo at <repo path>, open the web hub, run the release-check durable job from the Tasks tab, and report the phase it stops at. Verify that it waits for approval before any publish step runs.

  • Reopen an AI conversation after closing its session

    Close a session from the picker and later restore the exact conversation it held.

    View prompt
    Using Session Kit from https://github.com/dob323/session-kit, close the session numbered <n> from the picker, then reopen the conversation after running `kit`. Verify that the restored conversation matches the closed one and report which session number it appears under.

  • Find and install a vetted DSH plugin

    Use the listed marketplaces to browse plugins, then install one into your DSH profile.

    View prompt
    Using the DSH list at https://github.com/Dominic789654/awesome-deepseek-harness, install the dshmarket plugin into the web profile, then find one plugin in the marketplace matching <desired-feature>. Report the plugin name and its install command. Verify the plugin appears in the DSH settings page after refresh.

  • Give Hermes Agent a browser with five tools

    Connect Hermes Agent to Bladebro's browser tools with one setup command.

    View prompt
    In Hermes Agent with Bladebro enabled, open <site URL> using the browser tools and report the page title and main content. Verify with `bladebro hermes status` that the setup is active before you start.

  • Read pages that block simple scrapers

    Use DonSeTch's stealth fetch and browser escalation to read pages that serve bot walls.

    View prompt
    Using the donsetch MCP server, fetch <URL> and return the main article text. Confirm the response is page content rather than a bot challenge, and state which fetch tier succeeded if the output says so.

  • Add a new messaging channel with an AI coding agent

    Point a coding agent at AGENTS.md and the channel contract to build one new channel as a declarative definition.

    View prompt
    In the Dpro-at/Tel-Agent repo, read AGENTS.md and CLAUDE.md, then implement the open channel issue <issue number> using the declarative setup contract. Expected output: a focused branch with the new channel definition and transport, and a pull request description that references the issue. Verify that the change follows the rules in CLAUDE.md and that the project tests pass locally.

  • Run parallel analysis of a codebase with swarm mode

    Split one review goal into separate analysis tasks and collect the combined results.

    View prompt
    Use the dragonked2/alphacode repo's swarm mode on <repository path> to review architecture, testing, and performance in parallel. Return one combined report with file references for each finding. Verify that at least three findings point to real lines in the repository.

  • Build a cited knowledge base of people and commitments

    Get six cited pages on people, commitments, threads, products, issues and reading from one day.

    View prompt
    Using the dragthelake/ambient-context knowledge folder, read KB/<placeholder date>/commitments.md and list each commitment with its owner and cited block. Expected output: a table with columns commitment, owner and source block. Verify that every row has a citation that exists in Days/<placeholder date>/.

  • Trace every LLM call to debug a run

    Inspect prompts, responses, tokens and latency for each stage of a run.

    View prompt
    In the repo https://github.com/dreamscroll-lab/asamana, run a world for 3 steps and open the Trace view. Report the stage name, token count and latency of the first recorded LLM call for one character. Verify that each recorded call is linked to a stage from the five-stage pipeline.

  • Hand off an unfinished task card to a new agent

    Continue a half-done task with a different agent using only its card ID.

    View prompt
    In the dualface/kander repo, take over and continue task card <TASK-ID>. Report the card's current status, what has already been completed, and what remains. Verify the status against the board before you make any changes.

  • Prepare a part file for a 3D printing or CNC service

    Export a generated part in a format a 3D printing or CNC fabrication service can take.

    View prompt
    Using the text-to-cad plugin from https://github.com/earthtojake/text-to-cad, export <model file path> as <format the service accepts>. Return the exported file path and confirm the file opens correctly in the CAD Viewer.

  • Keep agent transcripts and app state on your machine

    Store projects, sessions, and transcripts locally without a Waku account or hosted service.

    View prompt
    On this machine, install Waku from the README and start one session in the project at <project path>. Expected output: a local listing of ~/.waku that includes app.json. Verify that no sign-in step was required to create the session.

  • Turn a street scene into a rainy night with puddles

    Set a street scene to night with rain, wet surfaces, puddles and lightning using agent-run skills.

    View prompt
    Using the blender-skills repo, change <street scene .blend> to a rainy night with puddles and lightning, then render one test frame. Expect the rendered image and a short list of the lighting and weather changes made. Verify that the puddles sit on flat ground and not on slopes, and that the lightning flash is visible in the render.

  • Screen prompts for PII and prompt injection

    Add guardrails that check requests, responses and streams before models see them.

    View prompt
    Using the eliasbiondo/antirion README, enable the PII guardrail for the key <key name> in the console and send a test request containing a fake email address. Expected output: the request is redacted or blocked as configured. Verify the result in the Request log.

  • Add your own bot prompt to the directory by pull request

    Write one markdown file in bots/, validate it locally, and open a PR that CI checks.

    View prompt
    In a fork of https://github.com/elie222/botdirectory.ai, create bots/<slug>.md with valid frontmatter and a prompt that starts with You, then run pnpm validate. Report the validation output and the pull request URL, and verify that the file changes only bots/<slug>.md.

  • Build and run Rakazo from a source checkout

    Clone the repo, set up the database, and start the dev stack to change the code.

    View prompt
    In the Rakazo repo at https://github.com/elie222/rakazo, follow the Local development (source checkout) section to get the dev stack running on this machine. Report the Node.js and pnpm versions used and whether pnpm dev started. Verify that http://127.0.0.1:5173 responds before reporting success.

  • Evaluate the agent on LIBERO and its robustness variants

    Follow the README evaluation guides to test EMERGE Policy on standard LIBERO, LIBERO-Plus, and LIBERO-Pro.

    View prompt
    In the EMERGE-Policy repo, read scripts/LiberoPlus_eval/README.md and run the evaluation it describes for the suite "<suite>". Expected output is an evaluation result file or summary from that suite. Verify that the LIBERO-Plus assets are present under third_party/libero_plus before starting.

  • Review AIKON privacy and API spending before going live

    Check data retention, limits and billing controls before you point real API keys at your phone server.

    View prompt
    Read the Privacy and cost section of the AIKON README and list every place data is stored, for how long, and every cost that is billed to my API keys. Expected output is a short checklist with one line per item, with the spending-limit step marked as a manual action. Verify that you did not invent any limit numbers that the README does not state.

  • Trigger a deploy or mirror after each successful push

    Use a post-receive hook to start CI, deploy code or mirror a repo after a push lands.

    View prompt
    In the enroute-sh/enroute repository, read docs/reference/hooks.md and write a post-receive handler in <app-dir> that starts a deploy script for <repo-name>. Expected output: the handler runs after a successful push. Verify by pushing a commit to main and checking the deploy script log.

  • Review what each Claude Code subagent brought back

    Use subagent lanes and the agent lens to see how each subagent in a Claude Code session contributed.

    View prompt
    Using the agentplay repo at https://github.com/Entelligence-AI/agentplay, run `uvx agentplay`, open the Claude Code session <session name or id>, and use the agent lens to scope to each subagent. Report which subagents produced edits or outputs and which came back with nothing. Verify by checking each subagent lane against its entries on the timeline.

  • Test a running app by driving devices in the browser

    Tap, swipe, and type on live iOS and Android screens from one browser wall.

    View prompt
    Using the simfleet repo (entropyconquers/simfleet), start `simfleet serve` in <path-to-app>, then open the dashboard at http://127.0.0.1:8790. Expected output: each booted simulator and emulator shown on the wall with its state. Verify that a tap sent from the dashboard changes the screen on the target device.

  • Follow and review agent work in the Codex on Crack panel

    Watch phases, handoffs, and tool activity, then leave feedback without interrupting the agent.

    View prompt
    Connect the workspace at <workspace path> to the Codex on Crack panel and list its registered phases, agents, and handoffs. Expected output: a summary of the run with timing and available token counters, with missing values shown as unknown. Verify that no feedback has been treated as approval.

  • Review bias evaluation methods for game NPC LLMs

    Find the FAIRGAMER paper and related work on social bias in game characters.

    View prompt
    Using the Eurekaleo/awesome-ai-for-games README, list the papers in the Play and Act section that evaluate bias, social behavior, or persona consistency in game agents, with their links. Verify that FAIRGAMER appears in your list.

  • Self-host the Skill Corpus retrieval models

    Serve the released bi-encoder and reranker behind your own /embed and /score endpoint.

    View prompt
    In the SkillCorpus repository, install skillcorpus/match/requirements.txt, start the server with run_server.sh using the released EverMind-AI bi-encoder and reranker checkpoints, then send a test query to /embed and /score. Report the top three skill ids for <task description>. Verify that the scores are returned for each candidate.

  • Export a trace report with structure only

    Create a shareable JSON or HTML report that removes free text and original identifiers.

    View prompt
    Using the TraceCrate repo at <repo path>, load <session file path>, export a Structure only report with timing and token minimization enabled, and save it as <output path>. Expected output: a JSON or HTML file with no raw free text. Verify by reading the full download, since event order, counts, and statuses remain and can still be sensitive.

  • Export routed-expert cache traces for analysis

    Dump expert usage traces from a run so the included cache simulator can replay them.

    View prompt
    In the repo FareedKhan-dev/kimi-k3-in-c, run a short generation with --dump-cache-trace <trace_dir> and --incremental. Expect expert_hist.json and expert_trace.bin in that directory. Verify both files exist and are non-empty before replaying them with tools/sim_cache.py.

  • Build the Termish Android debug app from source

    Compile a debug Termish APK from the open-source code with Gradle and the Android SDK.

    View prompt
    Using the farlume/termish README, build the Android debug app from a local clone at <path>. Expected output: a debug APK produced by `./gradlew :composeApp:assembleDebug` with no release signing keys. Verify that the build command ran from the repository root.

  • Get design tokens and a font sheet for a product

    Export the chosen palette and type as CSS, SCSS, Tailwind or DTCG JSON tokens with a font sheet.

    View prompt
    Using the repo fatihaydost/brand-identity-skill, build the kit for the set I pick from <brief> and export its design tokens as CSS and Tailwind. Expected output: token files and a font sheet with embed code. Verify that the font sheet links to the fonts rather than redistributing them.

  • X-ray a real clip to draw its hidden inside

    Film a working object and draw its mechanism on the frames its sound describes.

    View prompt
    Using the showtime skill in the FavioVazquez/showtime repository, analyze <clip.mp4> with `showtime xray analyze`, then build an X-ray project with `showtime new xray`. Expect a rendered film and a receipt. Verify that `showtime xray verify` reports the events on their frames.

  • Change the TV head by building from the repo source

    Clone the repo, run the playground on its source, and rebuild the library after edits.

    View prompt
    Clone https://github.com/fayazara/robot-heads, run `pnpm install`, then `pnpm run typecheck` and `pnpm run build`. Expected output: a dist/ folder with the built library and no type errors. Verify that the build succeeds before reporting any changes to the TV head under src/tv/.

  • Set up an offline AI guide for lab questions

    Download the small local model in Settings so the guide answers lab questions without sending text off the computer.

    View prompt
    In the Discover AI desktop app, open Settings, set up the Local model, then open lab 1 and click Ask the guide. Expected output: a reply from the local guide about lab 1. Verify that the reply appears without an API key being entered.

  • Write Python browser scripts on the engine library

    Use the invisible_playwright engine from Python code, with Playwright's API, instead of prompts.

    View prompt
    Using the invisible_playwright library from feder-cr/invisible_playwright, write a Python script that opens <target-url>, reads <element-or-field>, and prints the value. Expected output: the printed value and the URL it came from. Verify that the script stops with an error, not a guessed value, when the element is missing.

  • Plan a motion film beat by beat before rendering

    Use the rhythm and carry method to write a beat sheet where shot lengths vary and every boundary has a carried element.

    View prompt
    Using the onetake skill in the feitangyuan/onetake repo, write a beat sheet for a <length> teaser for <product>. Output one sentence per concept, then the chosen beat sheet with shot lengths and a named survivor at every boundary. Verify that shot lengths vary by at least four times and that no boundary is left without a carried element.

  • Keep a research library current as files change

    Schedule Carrel to scan a research folder so new papers and notes show up in agent answers.

    View prompt
    Use the FengZhenfei/carrel repo to search the research library at http://127.0.0.1:9810/search for <topic>. Report whether results include a document added in the last week. Verify the returned sources are dated or named after the new file before reporting success.

  • Install the three Finn Loop skills into a GitHub repo

    Copy the finn-spec, finn-build, and finn-review skills into a repo and check that the prerequisites are working.

    View prompt
    Inside the GitHub repo at <repo path>, follow the Finn-loop install steps from the README of finn/Finn-loop using the Linear team key <team key>. Expected output: the three SKILL.md files under .claude/skills and a smoke-test report. Verify that /skills lists finn-spec, finn-build, and finn-review.

  • Show nav2 costmaps from a rosbag2 replay next to robot poses

    Replay a rosbag2 with nav2 costmap topics and inspect the layers on one timeline.

    View prompt
    In the Flaminis/Dalaran repository, replay <bag_path> into a .dlr file using the ROS 2 bridge and open it with the dalaran command. Expected output is a viewer showing nav2 costmap grids on the timeline. Verify that the global and local costmap entities appear and that lethal and inflated obstacle cells are shown as separate categories.

  • Add an onboarding checklist with a live progress bar

    Show new users a step list whose progress bar and ticks update as they finish each task.

    View prompt
    Add the progress-tracker item from https://www.affectui.com/r/progress-tracker.json to the <project-path> React 19 project and render it on <dashboard-file> with the onboarding steps from <steps-source>. Expected output: a rendered checklist whose progress bar matches the number of completed steps. Verify that the bar value changes when one step's completed state changes.

  • Set up a self-hosted team server for shared agent history

    Join every teammate's devices into one searchable archive on a server you run.

    View prompt
    In the flopwire/flopwire repo, follow docs/two-laptop.md to start the team server and verify with `docker compose exec -T flopwire flopwire fingerprint` that it prints a sha256 fingerprint. Report the server address and the fingerprint, and confirm that `flopwire login` works for <admin-email>.

  • Show a code on a sign that the person can copy and paste

    Put a PIN or code on a sign with a copy button and point at the field to paste it into.

    View prompt
    Use the bigarrow CLI from franzenzenhofer/big-arrow-on-the-screen to point at the text field <field label> in <app name>:<window title> and show the sign "<sign text with {{<code>}}>". Expected output: a sign with a copy button and an exit code of 0. Verify the exit code and do not repeat the code in any other output.

  • View a session graph in the browser with no install

    Drop a transcript onto the hosted page and get the same graph without installing anything.

    View prompt
    Using the hosted zoetrope app at https://zoetrope.furkankly.dev/app, load the transcript at <transcript-file-path> by dropping it on the page. Expected output: the same agent graph the zoe binary would show for that session. Verify that at least one agent appears in the graph before reporting success.

  • Follow podcasts and video channels in one app

    Import the podcast and video bundles to listen and watch in Tidings with playback controls.

    View prompt
    Use the tidings-rss repo to import tidings-podcasts.opml and tidings-videos.opml into Tidings. Report how many podcast and video feeds were imported and which one returned no new episodes.

  • Run FuXi with bypassed approvals inside a container

    Let FuXi run tool calls without prompts, but only inside a disposable container or VM.

    View prompt
    Inside a disposable container or VM, install FuXi from fuxicodex/Fuxi and start it with `fuxi --dangerously-skip-permissions` in the repository at <repo-path>. Expected output: the session starts in bypassPermissions mode and completes the requested change. Verify by checking the diff in the repository and confirming nothing outside the sandbox changed.

  • Find who holds more than 1% of an IDX stock

    Import KSEI's monthly holder register and list every holder above 1% for one ticker.

    View prompt
    Use the idx tool from the fzn0x/idx repo to run `idx ownership import --latest`, then `idx ownership ticker <ticker>` for <ticker such as BBCA>. Return the holders above 1% with their stake. Verify that the output names the month the register covers.

  • Upscale and color-grade a result for final delivery

    Take a generated or edited image to 2x, 4K or a custom width, then apply a LUT look.

    View prompt
    Using the Kokon app, upscale the image at <image path> to <target width> pixels wide and apply the color look <LUT name or .cube path>. Expected output: a saved image file at <output path>. Verify that the output width equals the target width.

  • Build and test OpenClip from source

    Clone the Swift project, generate the Xcode project, and run the dev and test scripts.

    View prompt
    Clone https://github.com/ganeshmshetty/openclip on a Mac with macOS 14+ and Xcode 16+, run `xcodegen generate`, then run `./scripts/test.sh`. Expected output: the test script completes and reports its result. Verify the exit status is zero before reporting success.

  • Render a glTF model in a lit 3D scene

    Load a glTF or GLB model into a Framefields 3D scene with a LookAt camera and render it to MP4.

    View prompt
    In the framefields repo, create a composition that loads <model file>.glb into a 3D scene with a LookAt camera and studio lighting, and render it to output/<name>.mp4. Expected output: an MP4 of the model. Verify the file exists and that the model is visible in the first and last frames.

  • Make transparent-background icons for app projects

    Generate an icon with a transparent background and check that the PNG really has alpha.

    View prompt
    Using GPT Image Skill in <repo path>, generate a flat icon of <icon subject> at 1:1 with a transparent background. Expect a transparent PNG under /generated-images with a PATH=... line. Verify the file has an alpha channel before it is used in <project path>.

  • Ask a question and get answers cited from your files

    Star a set of documents, then use Ask AI on the home screen to get answers with a citation for each claim.

    View prompt
    In GenOffice, star the files in <folder> and ask Ask AI: '<question>'. Expected output: an answer where every claim has a file citation. Verify by opening at least two citations and checking that the cited passage supports the claim.

  • Give an agent the full catalog in one document

    Load llms-full.txt, or run the site locally, so an agent can reason over every file.

    View prompt
    Read the catalog at https://www.growth.engineer/llms-full.txt and list every workflow whose inputs match <the inputs you have>. Report the workflow titles and the tools each one uses, and confirm that each title appears in the document before you list it.

  • Audit token use and stream failures over the last week

    Summarize requests, tokens, and failed streams per model or account from the local database.

    View prompt
    In the underclass repo at <repo path>, with the server running, run `underclass stats --since 7d --by model` and save the output. Expected output: a UTC table with requests, tokens in and out, and event columns. Verify that the totals match the sum of the per-model rows.

  • Publish a bot to Marketplace after review

    Draft a public Marketplace listing with your bot and approve it before any pull request.

    View prompt
    Using the gitbot-hq/GitBot package, open <bot name> and run Publish to Marketplace in its conversation. Expected output: a draft listing and a final diff shown to the user before any pull request is prepared. Verify that copying the prompt alone published nothing and that the bot waited for approval.

  • Plan an FDE skills path from the reading list

    Turn the Getting started list into an ordered four-week study plan for a new FDE.

    View prompt
    Read the Getting started section of global-fde/awesome-fde-resources and build a four-week study plan for a <role or background>. Output one resource per week with its link and a check question. Verify every link comes from that section.

  • Give a custom agent lookup and inject tools from Semantix

    Register two tool schemas so a self-hosted agent can query and reuse Semantix memory.

    View prompt
    Using the Gnosil/semantix repo, register the semantix_lookup and semantix_inject tool schemas from agent-skill/tools/ in <agent>. Run one task that should match an extracted session and report which slices the lookup returned. Verify that the agent still completes the task when the semantix binary is removed, since the README says the kernel fails open.

  • Evaluate the controller on vision-language tasks

    Run the Qwen2.5-VL controller on A-OKVQA, AI2D, or M3CoT.

    View prompt
    In the repo GongZhiren/State-of-Thought, install the package with the vlm extra, choose the Qwen2.5-VL config under experiments/paper/, then run sot data validate and sot evaluate on it. Report the benchmark, the backbone variant, and the evaluation summary path.

  • Install and check the ARTEMIS helper on a phone

    Pre-install the accessibility helper and run diagnostics before a test session.

    View prompt
    In the google/artemis repo, run `uv run artemis helper install`, then `uv run artemis helper status`, then `uv run artemis doctor` against the connected device. Expected output: the helper status and the doctor report. Verify that the helper is listed as installed before any test task is started.

  • Approve or reject agent memories in the Graphicle app

    Review the memories your agents propose and keep only the ones you approve.

    View prompt
    In the Graphicle-AI/graphicle repository, run `graphicle open` for <repo-path> and review the memories waiting for approval. Expected output: a browser view of the graph, sources and memory with pending memories listed. Verify that a memory you approved is shown as reviewed and that a memory you rejected does not appear in new sessions.

  • Give an MCP-only host read-only project recall

    Serve recall and read tools from OwnMem to a host that has no hooks.

    View prompt
    In the repository grpcer/ownmem, register `npx ownmem mcp` as an MCP server in <host name> following the Plugins guide. Expected output: the host lists exactly two tools, recall and read. Verify that the host cannot call audit, trust, compile, or any write operation.

  • Add free narration and join it under your clips

    Record narration in a Google or Mac voice, then join it under your clips with music.

    View prompt
    Using the flow-mcp repo at <repo-path>, record the narration text <narration-text> with the free engine, then join the clips in <clip-folder> in order under that narration with background music. Expected output is one MP4 in ~/flow-mcp-out/. Verify that the file plays and the narration is audible over the lowered clip sound.

  • Animate a logo sting in a few minutes

    Run the logo-sting pipeline to get a 3 to 8 s logo animation with one directions review and a final.

    View prompt
    Using the repo GTKottman/mortiflix-oss, create a logo-sting project for <brand name> with `mortiflix new logo-sting` (inferred command). Run `mortiflix run` and report the directions gate. Verify that the output has a directions review before the final.

  • Use the remove-ai-marks skill in Cowork sessions

    Upload the packaged skill to claude.ai and point it at a reachable service.

    View prompt
    In a Cowork session with the uploaded remove-ai-marks skill, inspect <file path> through the watermarks-remover service at <service URL>. Report the provenance marks found and confirm the service responded to the health check before inspection.

  • Make a lesson board in Arabic, Urdu, Hebrew or another language

    Render a board where the writing runs right to left or left to right in many scripts.

    View prompt
    Using the khan-explainer skill, create a lesson in <language> with the scene set to lang <language code> and render it to an MP4. Expected output is a narrated board MP4 with correct writing direction. Verify with the contact sheet that the text reads in the right direction and is not clipped.

  • Self-host governed memory on Postgres

    Run a durable kernel on Postgres and pgvector with Docker Compose, backups, and generated keys.

    View prompt
    In the halofy repository, read docs/self-hosting.md and list the steps needed to run the kernel on Postgres with Docker Compose. Verify that the guide covers backups and restores before reporting the plan.

  • Read what your agents did overnight in one brief

    Get a morning summary of agent work, pending approvals and daily cost, with links to each source.

    View prompt
    Using the Bloks repo at hamedgitty/bloks, enable the morning brief and run one routine for the agent <agent-name>. Expected output: a morning brief listing what <agent-name> did, what is waiting on you and the day's cost, with a link for each line. Verify that each line links to a real conversation or file.

  • Compare model token prices before picking a model

    Check per-token rates and update times for OpenRouter and multi-vendor models, and sync official prices.

    View prompt
    Using the dsh-cost-meter plugin in DeepSeek Harness 0.2.0 or later, search the price catalog in Settings → Cost → Prices for <model name> and report its input and output token rates and last update time. Verify the rates against the official model link shown in the table.

  • Pull the live price board into your own analysis

    Fetch the public price board over HTTP to compare model prices in a script or spreadsheet.

    View prompt
    Fetch https://grandet.ai/api/v1/board and read the field description at https://grandet.ai/public-data/price-finder.json. Produce a table of listed prices for <model name> with source, unit and observation date, and do not compare USD, CNY or cash prices with each other.

  • Run the test suite and parity sweep on the orb engine

    Check the Swift engine against the original web geometry before you rely on it.

    View prompt
    In the ThinkingOrbs repo (https://github.com/haplollc/ThinkingOrbs), run `xcodebuild test -scheme ThinkingOrbs -destination "platform=iOS Simulator,name=iPhone 17 Pro"` and `Scripts/differential-sweep.sh`, then report the pass or fail result for each. Verify that the sweep reports zero mismatched frames before you claim parity.

  • Read long confidential files in one 1M-token window

    Send a large document to the local 27B model with a 1M-token context.

    View prompt
    Use the repo hasso5703/dgx-spark-qwen38 to send <document-path> to the local stock Qwen3.8-27B lane through its OpenAI-compatible API. Expected output: a summary and answers to three questions about the file, generated on the box. Verify that three answers match passages you have checked by hand.

  • Give an MCP client on-demand access to full originals

    Install the Headroom MCP server so the model can fetch uncompressed text when it needs it.

    View prompt
    Using the repo headroomlabs-ai/headroom, run `headroom mcp install` and connect the MCP client to the headroom server. Compress the file <file-path> with headroom_compress, then call headroom_retrieve to get the original back. Expected output: the original text matches the source file. Verify that the retrieved text equals the source.

  • Fold Claude Code's routine output to keep long sessions calm

    Turn on calm mode to remove motion and fold reads and searches into single lines.

    View prompt
    In Claude Code with hellosverre/claude-skins installed, run `/skin calm`, then ask Claude to review <target folder> for a bug. Expected output: reads and searches appear folded and failures appear whole. Verify by running `/skin calm off` and confirming the earlier drawing returns.

  • Build the repo from source and run compatibility checks

    Clone the source, build it, and check a card against the local compatibility benchmark.

    View prompt
    In the repo hewzhew/dsh-agent-rp, clone the source, run `pnpm install` and `pnpm run build`, then follow docs/compatibility-benchmark.md to test the card at <path-to-card>. Report the build result and any failing compatibility checks. Verify that the build succeeds before running the benchmark.

  • Test how often the effort judge picks the right level

    Run the bundled judge benchmark on your own Claude Code setup before trusting Auto.

    View prompt
    Clone HeyCubit/effortless, run `bash bench/agentic/run.sh` and report the cost per task for each effort setting it prints. Confirm the output matches the table in bench/RESULTS.md within a reasonable margin before drawing conclusions.

  • Fix mechanical PHP findings in one pass

    Let Rector and Pint fix the findings a machine can change, then review what is left.

    View prompt
    In the Heyosseus/sloppy project, run the fix command on the PHP repository at <project path>. Output the number of findings before and after the fix pass, and the findings that still need a person. Verify that the test suite of the project still passes after the fix.

  • Run AI Builder locally and fork it to customize

    Clone the repo, install dependencies, start the dev server, and change the Builder for your own use.

    View prompt
    Clone the HeyPuter/builder repo, run npm install and npm run dev, then change <target file or feature> to add a small customization. Expected output: the builder running locally with your change visible. Verify that the dev server starts without errors and the change appears after reloading the page.

  • Audit which model ran each agent step and what it cost

    Check per-session model, usage and cost so you can tune routing with real execution data.

    View prompt
    Using the HiRoute repo at https://github.com/higress-group/HiRoute, review the most recent session for <target agent client> and list each turn's task category, actual model group, usage and cost. Verify that the model shown is the one that actually ran, not the one the routing plan intended.

  • Schedule Agent tasks with approval and audit controls

    Run scheduled tasks while sensitive tool actions wait for approval and executions stay traceable.

    View prompt
    Using the repo himovo/movo, deploy it with ./movo up and configure a scheduled task that calls <tool name> with an approval requirement. Return the task ID and the execution trace, and verify that the sensitive action waits for approval before it runs.

  • Edit a Blender scene with a local Ollama model

    Use Ollama instead of a cloud key to have the agent change objects in your scene.

    View prompt
    Configure the hitkeeen/blender-ai-addon AI Copilot with the Ollama provider and model llava, then send the request <describe the scene edit> in the chat. Expected output: a bpy script that modifies the named object in the open scene. Verify that the server reports OpenCode ready and that the edited object changes in the viewport.

  • Launch Codex through the local gateway

    Start Codex with the gateway as its backend using the built-in launcher.

    View prompt
    In the my-free-code repository, confirm the codex command is on PATH, start the gateway with python -m my_free_code, then run python -m my_free_code.cli.mfc codex. Expected output: Codex starts and completes a short test task. Verify that the gateway log records the request.

  • Have an agent manage Zotero library items and citations

    Let an agent handle Zotero collections and citations through a CLI built for the Zotero desktop app.

    View prompt
    Using the HKUDS/CLI-Anything Zotero CLI, list the collections in my library and generate a citation for the item titled <item-title>. Report the collection names and the citation text. Verify that the citation includes the author and year.

  • Keep approved project decisions in a source-bound memory ledger

    Save room decisions as memory records that stay tied to their source evidence.

    View prompt
    In the Hoylon/peerbridge-mcp control room, create a Room memory record from the decision in <room-id> and ask a human to approve it as a Project record. Report the record ID and its source SHA, and verify that the record links to the original evidence.

  • Write one function in C and check it against the ROM

    Edit a function in the app, press Ctrl+Enter, and see the judge's diff against the original.

    View prompt
    Using the decomp.wtf repo (i12bp8/decomp.wtf), open the bundled Demo Quest 64 ROM and write C for one function of your choice in the editor. Report the score the judge gives and the instruction diff, if any. Verify that the function only counts as matched when the score is 100 and the bytes are identical.

  • Compare two video drafts side by side in sync

    Flip between versions of a video Claude Code made, or play old and new drafts together in one player.

    View prompt
    Using the claude-show-your-work plugin in Claude Code, produce two versions of <target video> and show them side by side in sync. Expected output: both versions playing together in the chat, with earlier drafts listed in History. Verify that playback stays in sync between the two versions.

  • Let an agent read a task's trajectory through MCP

    Have Codex call the trajectory tools to pull a safe structured summary of a specific task.

    View prompt
    Using the icesixgod/codex-trajectory repo, call get_codex_trajectory with the sessionId <sessionId> and return a safe summary of that task's steps and timing. Verify that the reply has no tool inputs, outputs, or raw metadata, since those stay hidden in the safe summary.

  • Map a web app's flows with playwright-cli before testing

    Use playwright-cli to explore a live app, trace its flows, and inspect storage before writing tests.

    View prompt
    In the agentic-playwright repo, use playwright-cli to explore <app-url> and capture the login and main navigation flows. Expected output: a summary of screens, selectors, and storage state that is usable for page objects. Verify the summary names the flows walked and that no test code was changed.

  • Get a multi-reviewer critique of a draft before submission

    Use the Academic Paper Reviewer skills to get several simulated reviewer perspectives on a draft manuscript.

    View prompt
    Using the repo Imbad0202/academic-research-skills in Claude Code, run the Academic Paper Reviewer skill on the manuscript <path to draft>. Expected output: multi-perspective reviewer critiques with evidence-anchored judgements. Verify that the reviewer left the draft file unchanged and that each judgement cites a passage from the manuscript.

  • Benchmark depth-aware serving on your own GPUs

    Reproduce the published baseline protocol on your hardware before choosing a serving layout.

    View prompt
    In the vllm-rlt repository, follow the protocol in the linked PR #30 and PR #31 to benchmark Ouro-1.4B BF16 on <your GPU setup> with a single replica and with a split prefill/decode layout. Output a table of throughput, TTFT, and ITL for each layout. Verify that the workload settings match across both runs.

  • Transcribe a track or stem into MIDI notes

    Convert a full mix or a single separated stem into MIDI with a built-in piano roll and .mid download.

    View prompt
    Using the repo inikolax/remiqora, set YuE2 as the active model and transcribe the stem <stem name> to MIDI. Expected output: a .mid file with the note count and BPM shown in the app. Verify that the MIDI file opens in a MIDI editor and the note count matches the piano roll.

  • Compare the Workers, Postgres and React Router setup with yours

    Review how Inkloom serves its app and API from one origin and gates database migrations, to inform your own stack.

    View prompt
    In the Inkloom-art/inkloom repository, find where the session cookie is set and where database migrations are gated on identity. Summarise each design choice in two sentences and name the file for each. Verify by quoting the file path and the code line that sets the cookie or checks identity.

  • Study a review-gated agent loop with repair rounds

    Read how Noobi AI bounds agents with read-only roles, three repair rounds and a host proof gate.

    View prompt
    Clone the Noobi.ai repo to <path>, read docs/ARCHITECTURE.md and the prompt contracts in src/main/gameHarness.ts, then write a short summary of how the Planner, Implementer, Reviewer and repair rounds hand off work. Expect a summary that names each role's permissions and the host proof gate; verify each claim against the source file before relying on it.

  • Import agent conversation history from your computer into Lody iOS

    Pull chosen local agent conversations into the iPhone app from Settings, with manual confirmation.

    View prompt
    Using the Innei/lody-ios repo README, list the steps to import selected agent conversations from a computer into Lody iOS using Agent Conversation Sync. Output a numbered list. Verify that the output states this is a manual history import and not automatic device-to-device mirroring.

  • Get alerts when new award winners match your watched studios or tags

    Poll new winners and watch studios or tags, then report only what changed since the last check.

    View prompt
    Use the awwwards-mcp server to call new_winners to set a baseline, then add a watch_site entry for the tag <tag name>. Expected output: a list of new winners and per-watch NEW since last check deltas. Verify that a second new_winners call reports only winners that were not in the first listing.

  • Route judgments to a self-hosted CLM or Laya model

    Point the connector at your own server to run CLM or Laya instead of the hosted Jev.

    View prompt
    Using the evaluate tool from the itsmostafa/system-one-connector repo configured with a self-hosted CLM or Laya endpoint, ask whether <text> conveys urgency (noul question). Return the probability and the endpoint used. Verify that the response came from your local address and not a hosted one.

  • Change the rubric and strategy cards for your team

    Edit the five judging criteria and the strategy list, then run the arena with your rules.

    View prompt
    In the repo https://github.com/Jakeschincariol/arena-skill, edit skills/arena/rubric.md to reweight the five criteria as <your weights>, then run python3 -m unittest discover -s tests -v. Expected output: a passing test run. Verify that the weights in rubric.md still add up to the total the bracket expects before you run the arena.

  • Compile a business plan with a computed verdict

    Assemble all the founder files into one plan with a verdict from the numbers.

    View prompt
    Using the Jakeschincariol/founder-skill repo, run `python3 skills/founder-plan/compile.py --dir founder` and report the verdict (Profitable, Not yet or Incomplete) and the reason for it from founder/business-plan.md. Verify that the verdict comes from the computed checks on unit economics, year 1 profit, break-even against capacity and the share of the panel that buys, and not from prose.

  • Plan a week of LinkedIn posts and 10 engagement targets

    Get a weekly plan of what to post, when to post it, and who to comment on.

    View prompt
    Run the li-plan skill from https://github.com/Jakeschincariol/linkedin-agent-skill for the week of <date>, using my voice file and the topics: <topics>. Expect a plan written to ~/.claude/linkedin/plan.md with posts, timing and 10 engagement targets. Verify that the file exists and that no target was invented without my input.

  • Design a custom robot shell by changing the CAD files

    Edit the CAD source and print a new body or mod for the same electronics.

    View prompt
    Use the repo github.com/jamro/tiny-engineer and its CAD sources in 3d_models/. Open the CAD file for the shell, make <change description>, and export the printable parts. Expected output: printable files for the changed shell. Verify the servos still fit and move without touching the shell.

  • Run a hand-tracked overlay in an OBS scene

    Mirror the glass board into OBS as a transparent layer over your camera for streams and recordings.

    View prompt
    In the barehands repo, start server.py and confirm that http://127.0.0.1:8794/stage.html?role=render loads without errors. Expected output is a page load with no console errors in Chrome. Verify the cards are transparent when placed in an OBS browser source.

  • Study or rebuild the Odamex changes for the mod

    Apply engine/odamex.patch to the named Odamex commit to see or reproduce the headless engine changes.

    View prompt
    Clone jarrodwatts/intermission and Odamex, check out the commit listed in engine/odamex-commit, apply engine/odamex.patch, and report whether the patch applies cleanly. Summarize where frames are written and verify the GPL-2.0 note applies to the engine changes.

  • Collect Aider chat logs from all your project folders

    Find every Aider transcript across your project directories and export them to JSONL.

    View prompt
    Using the repo jatechan/ai-data-extractor, run the aider source with --search-path set to <project folder>, and report how many project transcripts were found and written. Verify that each output line includes a messages array and a project_path value that matches one of the searched folders.

  • Watch a running agent session from a phone browser

    Scan a QR code to follow a session from a tablet or phone and act on approvals.

    View prompt
    In the repo Jaxton07/percho, enable the cross-device QR view for the session <session-name> and report the URL scheme you see on the QR code. Verify that a second device can load the session read-only before any remote action is enabled.

  • Check agent quotas and sessions from iPhone on home Wi-Fi

    Share your Mac with the official iPhone app to see quotas and sessions without a server, on the same network.

    View prompt
    Open the official Agent HUD Mac app, turn on Settings → Local network → Share this Mac, then pair an iPhone on the same network. Verify that the iPhone Home view shows the same quotas as the Mac and report any mismatch.

  • Run a Fabric notebook on your own Spark hardware

    Send a Fabric notebook to your own Spark workers with olcf.run_remote() and read OneLake directly.

    View prompt
    Use the open-lakehouse-compute-fabric repo (jddevtime/open-lakehouse-compute-fabric) and its Fabric integration guide. Attach the olcf_fabric wheel to a Fabric Environment, call olcf.run_remote() on <notebook name>, and report the returned status and exit value. Verify that the target OneLake table has the expected row count after the run.

  • Fail a build when a site's AI readiness regresses

    Score the site on every push and fail the build on a regression or a zero gate.

    View prompt
    Using the geo-score repo at jianruntech/geo-score, add its GitHub Action to a workflow that scores <target-domain> on each push. Expected output: a build that passes with the score in the job summary and fails on a regression or a gate at zero. Verify that a deliberately broken robots.txt line causes the build to fail.

  • Test whether compressed experience transfers to a new task

    Compress execution experience from one task and score it on an independent held-out task.

    View prompt
    Using the EvoTrace repo at https://github.com/jinzijian/EvoTrace, build two independent verified assets from the same repository, then run /evolve <source-asset> <held-out-asset> in the DeepSeek Harness app. Report baseline and conditioned Docker reward results from /runs. Verify that the held-out asset was built independently and that a run with only one asset is treated as a wiring smoke test, not transfer evidence.

  • Run faster checks on a small change

    Switch to quick mode so a small change runs only the checks it can affect.

    View prompt
    In the <repo-name> repo, run /first-pass:quick, make the change described here: <change-description>, then run ship-check. Expected output: a report listing each check run and its result, and which checks were left for a full run. Verify that the report says which CI checks were not run.

  • Generate real pixel-art scenery for a route

    Spend a set budget on RetroDiffusion art for a route, with the quote shown before any money is spent.

    View prompt
    Using the pixel-path skill in the jonwheatley/pixel-path repo, bake a route from <start place> to <end place> at the sparse level after the estimate is shown. Expected output: a route folder with generated pictures and a contact sheet. Verify that the exact quote matches the estimate and that no API key appears in the output or the chat.

  • Merge duplicate entity names into one canonical view

    Assert alias edges and read facts through canonical names, with conflicts escalated instead of silently merged.

    View prompt
    Using the lemmalog MCP server, canonicalize the alias edges in <file> and then query current_canon for <entity>. Expected output: the canonical facts plus any alias_conflict entries. Verify that no local name maps to two canonical names.

  • Open an existing Obsidian vault and add a community theme

    Point Opensidian at a vault folder and install a theme into the vault's .obsidian folder.

    View prompt
    Given a vault at <vault-path> and a theme folder at <theme-path> containing manifest.json and theme.css, copy the theme into <vault-path>/.obsidian/themes/<name-from-manifest>/. Report the target folder path and the theme name from the manifest. Verify that the manifest name matches the folder name before reporting success.

  • Test BGM matching on the hosted endpoint

    Use a trial key on the hosted server to match music to a sample clip without installing Python.

    View prompt
    Using the hosted sonicmatch MCP server at https://sonic.codecrafter.dev/mcp, ingest examples/sample-clip.mp4 and recommend three tracks with their hook windows. Return the license and attribution for each track. Verify that the response includes the credit cost per tool call and that you did not publish any key in the output.

  • Compare two RAG retrieval setups without a model key

    Run baseline and candidate RAG configurations offline and review the deltas in a dashboard.

    View prompt
    In the EvalForge repo (https://github.com/jsdhwfmax/EvalForge), start the stack with `docker compose up --build`, then run `evalforge run baseline_top1 --name "Baseline" --output build/baseline.json` and `evalforge run hybrid_top3 --name "Candidate" --output build/candidate.json`. Expected output is two experiment JSON files; verify both share the same dataset fingerprint before comparing them.

  • Track a screenplay project's stage across sessions

    Use the workflow orchestrator and a story bible file to keep your screenplay's stage and decisions between chats.

    View prompt
    Using the screenwriting-skills repo (sw-workflow), set up a project for <project name> and create a story bible file that tracks the current stage, settled decisions and open questions. Verify at the start of each new session that the agent reads the file and states the current stage before writing anything.

  • Cross-check corpus facts against openFDA and ClinicalTrials.gov

    Run the fact-check and audit scripts to flag stale or contradictory oncology records.

    View prompt
    In a local clone of judegomila/OnCo, run `npm run validate`, then `npm run factcheck` and `npm run audit`. Expected output is a list of flagged record ids with the field, the stored value and the source value. Verify each flag against the linked primary source before reporting it as an error.

  • Redesign an existing landing page in your project

    Rebuild a landing page inside your own project and check it before shipping.

    View prompt
    Using the juliobsz/skills repo, run /awwwards inside <project folder> to redesign the landing page at <page path>. Expect updated page files, a DESIGN.md and screenshots for desktop, mobile and reduced motion. Verify that the production build still succeeds before you report the redesign as complete.

  • Let an agent act on GitHub through brokered MCP tools

    Connect GitHub through Claw Auth so an agent can work with your repos under your own access.

    View prompt
    In the xyne-spaces Claw setup, use the GitHub MCP tool through Claw Auth to list open issues in the repository <owner/repo>. Expected output: a list of issue titles and numbers. Verify that the tool call came from your own connection and that the result matches what you see on GitHub.

  • Check a judge's accuracy before it blocks a release

    Label judge verdicts against human review to catch over-flagging before it gates a PR.

    View prompt
    In the Tracely-ai repository, run `docker compose --profile demo up -d --build --wait` and open the calibration screen at http://localhost:3001. Label at least ten judge verdicts and report each evaluator's agreement, missed failures and over-flagging. Verify that the three numbers are shown for every evaluator you labeled.

  • Build your own AI Twin from reviewed Markdown

    Replace the example profile with your approved notes, set the app identity, and run the checks.

    View prompt
    Update the jzjzzzzzzz/agent-me checkout so the knowledge folder contains only the reviewed Markdown files I approve, then run the knowledge check. Report the document count and the output of make lint test docs evaluate. Verify that no file outside the approved list was added.

  • Render a moving mechanism as a video

    Describe a motion in Python and render the animation of a model to video.

    View prompt
    In the SOMA model folder for <model name>, write an animation in Python that moves <part name> through <motion description>, then run `soma render` to produce a video. Report the output file path and confirm the rendered video shows the expected motion.

  • Prototype a voice and camera desktop robot agent

    Follow the linked tutorial to connect a language model to a desktop robot with voice and vision.

    View prompt
    Using the NVIDIA and Hugging Face Reachy Mini tutorial linked in https://github.com/kairunwen/Awesome-Robot-Use-Agent, set up a voice and camera agent for a Reachy Mini and add one robot behavior as a ReAct tool. Report the steps completed and the behavior triggered by one spoken command. Verify the tool call appears in the agent log before you report success.

  • Strip dead air and set loudness to -14 LUFS

    An agent removes silent gaps from a recording and sets its loudness to the -14 LUFS target.

    View prompt
    Using the ffmpeg-skill repo, remove silences from <recording> with a -35 threshold, then normalize loudness to -14 LUFS with a -1 true peak. Expected output: a cleaned MP4 with the target loudness. Verify the result with probe.py and report the duration change.

  • Share one warm audio server across all sessions

    Run one local HTTP server so every MCP session uses the same loaded models.

    View prompt
    Using the audio-studio-mcp repo, start the server with `.venv/bin/audio-studio-mcp --http 8765 --preload` and register it with `claude mcp add --scope user --transport http audio-studio http://127.0.0.1:8765/mcp`. Then call generate_audio for a 3-second sound effect at <path or description> to verify the server responds, and check that a file appears in outputs/.

  • Build a custom Claude Code mod with Claude

    Ask Claude to build a mod, then test it locally with --plugin-dir before sharing it.

    View prompt
    Using the karanb192/awesome-claude-code-mods repo, build a local Claude Code mod for <task> at ./path/to/plugin. Expected output: a plugin folder that loads with `claude --plugin-dir ./path/to/plugin`. Verify that the plugin loads and that its behavior matches the task before sharing it.

  • Compare old and new tax regimes with exact rupee savings

    See the tax under each regime side by side and which one saves more.

    View prompt
    In the itr-wala repo at <repo-path>, validate <your-income-file> for FY 2025-26, then run the tax engine on it. Expected output: old and new regime totals with the recommended regime and the rupee saving; verify the validator passes before you report the comparison.

  • Check a redesign against the craft audit rules

    Run the Node audit on a generated page to catch clipped content, focus problems, or invented facts.

    View prompt
    Use the reimagine-it repo to audit <path-to-redesign.html> by running `npx reimagine-it audit <path-to-redesign.html>`. Expected output: results for the 19 audit rules. Verify that every failed rule is reported and that the page still matches the source facts after any fix.

  • Generate a project image with agy's staffer persona

    Ask the general staffer persona to create an image and save it into the repo.

    View prompt
    Using the keli-wen/agy-staff plugin, ask the staffer persona to generate <image description> and save it to <output path> in <repo>. Expect a PNG at that path. Verify that the file exists and opens as an image.

  • Build and run BetterC0de from source for contributions

    Clone the open source repo, install pinned tools, and start the app in development mode to test a change.

    View prompt
    Clone https://github.com/kerim0x1/bettercode.git into <target-folder>, use the Node version in .nvmrc, run `npm ci`, then run `npm run dev`. Report whether the Electron window opens and paste any error with its first line. Verify by running `npm run verify:source` and confirming it exits with code 0.

  • Sort a mailbox into lanes with Jev

    Sort an inbox export into needs-reply, updates, promotional, sales and spam lanes.

    View prompt
    Using the hermes-jev-skills repo from kerpopule, sort the file <inbox.json> with `jev mail --file <inbox.json>` and then `--summary`. Report the count per lane, the messages Jev was unsure about and the total cost. Verify the lane counts add up to the number of messages in the file.

  • Turn pinned frames into durable style rules for agents

    Pin exemplar frames and let the guideline distiller propose rules every agent follows.

    View prompt
    In the repo kgoedecke/doop, with ANTHROPIC_API_KEY set, pin three exemplar frames on canvas <canvas-id>, then run the guideline distiller. Report the rules it proposes and state whether each one cites a pinned frame or a captured decision.

  • Add a new place to the yard simulation

    Follow the repo's folder layout to add a new building or area to the isometric world.

    View prompt
    In the repo Khalidabdi1/factory, add one new static building under yard/world/ and register it in yard/index.ts, then run `npm run build`. Verify that the build finishes without errors and that the new building appears when `npm run dev` runs.

  • Keep a plain-language status file for the whole project

    Maintain one BIG-PICTURE.md with every feature, its progress, unused parts and queued work.

    View prompt
    In the open-steps repo at <repo-path>, use the os-big-picture skill to update BIG-PICTURE.md for the project at <project-path>. Expected output: a plain-language file listing each feature with its progress, any unused parts and the queued work. Verify that no task was invented and nothing was deleted.

  • Route inbox messages into a table with a workflow

    Connect email and use a visual workflow to add incoming messages to a table as records.

    View prompt
    In the Kition desktop app, open the workflow <workflow name> that moves inbox messages into the table <table name>. Ask the Agent to report the run history for the last run and list any step with missing inputs, and confirm the records match the messages.

  • Export a narrated capture as a shareable MP4

    Turn a bundle into an MP4 with the activity cropped, ink burned in, audio kept, and optional auto-zoom.

    View prompt
    In the Scrawl repo, run `cargo run -- export latest --zoom --out <output.mp4>` and report the output path and duration. Verify that the MP4 plays with audio and that the ink marks are visible.

  • Build a remediation executor that dedupes commandId

    Write the external consumer that applies remediation commands safely under at-least-once delivery.

    View prompt
    In the kkjiangk/agent-py repository, read the remediation approval and dispatch documentation and draft an executor that deduplicates messages by commandId before applying side effects. Report the topic name and the storage you chose. Verify with a staging replay that a duplicate commandId causes no second side effect.

  • Read a login code from a phone notification during a test

    Wait for a notification on the phone and use its text in your test flow.

    View prompt
    Using the Droidline repo at https://github.com/KnifeLemon/Droidline, write a Python test that starts the sign-in flow in <app package name>, waits for the notification that carries the one-time code, enters it into the field with id <code field id>, and checks that the element with text <expected text> appears. Report pass or fail and the code length, not the code itself.

  • Test multimodal prompts in a lightweight chat page

    Send prompts that mix content types to an LLM from a single browser page.

    View prompt
    Using the Chat_UI repository at KODAMA-TECHNOLOGY/Chat_UI, configure a multimodal model at <api-endpoint>, send the prompt <multimodal-input>, and export the session. Report the model reply and verify that the exported history contains both the input and the reply.

  • Check a Bricks reference edit before merging

    Run the Bricks validation suite after changing a component reference.

    View prompt
    In the kostja94/bricks repository at <local path>, edit the reference for <component name> under skills/component-builder/references/components/, then run npm test. Report each failure with its file path and the fix you made, and confirm the final run passes.

  • Give a coding agent Jev skills for decision steps

    Install the TypeSafe agent skill so Claude Code or Codex can build Jev calls.

    View prompt
    Using the repo kraayenjon/awesome-jev and the TypeSafe agent skill from typesafe-ai/skills, add one Jev Choice decision step to <target function> in this project. The step should return a typed label that the existing code branches on. Verify that the project's test suite passes after the change and that the new call reads the API key from TYPESAFE_API_KEY.

  • Keep a tmux coding agent going through a Wi-Fi drop

    Set up iPhone hotspot handoff and a marked tmux pane so a coding agent can resume after the network drops.

    View prompt
    In the repo https://github.com/krishhgg/Insomnia, read docs/extras.md and list the steps to enable the iPhone hotspot handoff and tmux nudge for a pane named <pane-target>. Verify that the nudge option is off by default and that Enter is not pressed unless enabled, then report the result.

  • Restore only chosen segments of a video

    Use the Segment Editor to pick the parts of a video to restore and preview them before the run.

    View prompt
    Using the Jasna repo at Kruk2/jasna, open <input video path> in the Segment Editor, select the segments containing mosaics, and run the queue. Expected output: a restored video with only those segments changed. Verify by comparing a selected segment and an unselected segment with the original.

  • Shorten or hide tab titles with a config.env file

    Set title length, branch display, and position using a config.env file.

    View prompt
    In the repo kryptamine/herdr-auto-title, create ~/.config/herdr-auto-title/config.env on <target machine> from config.env.example with HERDR_AUTO_TITLE_BRANCH_MAX set to 0, then restart the plugin. Report the tab titles before and after the change and confirm no branch name appears in them.

  • Fill a booking form up to the last button at a set time

    Andee opens an app at the time you set, reads the page and fills everything up to just before the final button.

    View prompt
    Using the Andee repo at github.com/kuafuai/andee, schedule Andee to open <target app> at <time> and fill the booking form to just before the final button. Expected output: a filled form with the last button and payment left for the user. Verify that Andee does not enter a payment password or press the final confirmation.

  • Turn off Compact Adviser for unattended agent runs

    Set COMPACT_ADVISER_DISABLE so scripted or background sessions skip all advice and compaction.

    View prompt
    For the unattended agent job on <target host>, export COMPACT_ADVISER_DISABLE=1 in the job environment before launching the session. Expected output: the echoed variable value is 1 and the session produces no compact-adviser hints. Verify the value is 1 before the session starts.

  • Let a coding agent run Perch on its own changes

    Install Perch instructions for your AI coding assistant so it can scan its own edits.

    View prompt
    In the perch repo at <project path>, after you finish editing, run `perch scan` and then `perch issues`. Fix the top finding if it is a real defect, then run `perch check <id>`. Verify that the final scan lists no new problems introduced by your edits.

  • Review agent output and charts on your iPhone

    Read the same agent conversations on iPhone and open charts, pages and files the agent made.

    View prompt
    In the chums repo at <target-folder>, run bin/chums-doctor and report whether the iPhone app can reach the hub with the same address and token. Expected output: a read-only check of the whole chain with a fix for each failure. Verify that the hub check passes before using the iPhone app.

  • Arrange a multi-part score and export MIDI and stems

    Write parts by bar and beat, import MIDI or let an agent compose, render with a General MIDI sound font, and export.

    View prompt
    Using the leemysw/yovoice repo, create a Score project with the parts described in <arrangement brief> and export the MIDI and stems to <output folder>. Expected output is one MIDI file and one stem per part; verify that each part's bar count matches the brief.

  • Design a logo and a 6-second sting with alpha exports

    Get a logo sting with sound plus transparent versions for video editors.

    View prompt
    Use the cinetic skill from Leonxlnx/cinetic to design a logo for <product name> and make a 6-second logo sting with sound, plus ProRes 4444 alpha versions for light and dark footage. Confirm each alpha file has a transparent background before you report the output paths.

  • Drive Moli from Playwright over CDP

    Run a local Moli server and control it from an existing Playwright script.

    View prompt
    Using the repo lexmount/moli, start the server with `moli serve` and connect Playwright to http://127.0.0.1:9222 with connectOverCDP. Navigate to <target-url> and print the body innerText. Verify that the printed text matches the visible text of the page.

  • Compare full Jev Mem against ablated controllers on LoCoMo

    Run LoCoMo questions with full, write-ablated, and read-ablated Jev Mem to see which control layer changes answers.

    View prompt
    In the Jev-Mem repository at <target-folder>, run the LoCoMo benchmark on data/locomo10.json for sample 0 with 10 questions, once with the full config and once each with --no-jev-write and --no-jev-read, using separate --cache-dir paths. Report the three overall scores and confirm that all three runs used the same dataset subset.

  • Control Blender from OpenCode or another MCP client

    Connect OpenCode or another MCP client to the authenticated local endpoint and run Blender tools from it.

    View prompt
    Using the mcp-for-blender-pro repo, connect an MCP client to the authenticated local endpoint in docs/CONNECTIONS.md and call list_objects, then add_cube with a name of <object name>. Return the tool responses, and verify with viewport_screenshot that the cube appears in Blender.

  • List files of one type across a large folder fast

    Return every path matching a file pattern from a big tree without listing noise.

    View prompt
    Use the aside-codemode execute_code tool to list every file matching <pattern> under <root folder> and return the paths. Verify the path count against a find run on a small subfolder.

  • Export all visibility data as JSON or CSV

    Pull the whole instance into one JSON file or a folder of CSVs for your own analysis or board material.

    View prompt
    In the limelit-co/open repository, run `limelit export` for the instance in ~/limelit and write the output to <output-path>. Expected output is a JSON document or CSV directory covering all answers. Verify that the row count for <engine-name> matches the dashboard count for that engine.

  • Back up and export your full health history

    Take verified database snapshots and export your records as JSON, CSV, GPX or FIT for safekeeping.

    View prompt
    Using the ZeppBridge repository, explain how to take a snapshot of my local health database and verify it. Expected output: a short checklist with the steps and where the snapshot is stored. Verify that the checklist mentions previewing differences before restoring.

  • Compare skill installs across China and global registries

    Use the top installs file to see which skills lead on skills.sh, ClawHub and Tencent SkillHub.

    View prompt
    From rankings/top-installs.csv in the LinklyAI/best-skills repo, list the top five skills by SkillHub CN installs and the top five by skills.sh installs, and report any skill that appears in both lists. Verify that you treat empty platform cells as not listed, not as zero.

  • Build Lithos Metal from source for development

    Compile the native runtime from the repo and install an editable copy for changes.

    View prompt
    Using the lithos-metal repo at https://github.com/lithos-ai/lithos-metal, clone it, create a Python 3.12 virtual environment, and run `pip install -e '.[serve,dev]'`. Expected output is a successful install and a version string from `lithos-metal --version`. Verify the command prints a version before reporting success.

  • Pull the catalog index to audit plugin counts and rejections

    Read the published index.json and its data files to review what the catalog lists and rejects.

    View prompt
    Fetch https://LivXue.github.io/dsh-plugin-shop/v1/index.json and report the schemaVersion, builtAt, count, and rejected fields. Then fetch one plugins data file named in the index and confirm it parses as JSON.

  • Draft evidence-linked replies to reviewer comments

    Use AutoRebuttal to tie each reviewer concern to paper evidence before writing replies.

    View prompt
    In the repo liyingze07-svg/EffectiveAutoResearch-EAR-, follow docs/getting-started.md to prepare a rebuttal for the paper <paper-path> and reviewer comments <comments-path>. Expected output is evidence-linked replies, an AC comment and an unresolved-concern ledger as separate files. Verify that every reply cites a specific passage or result in the paper before you report it as supported.

  • Scout open frameworks for self-evolving agent harnesses

    Find frameworks in the list that evolve memory, skills, or harness code for an agent.

    View prompt
    Using the Frameworks & Tools section of the awesome-rsi README at lobehub/awesome-rsi, shortlist two or three frameworks that evolve <update target> for an agent. For each one, output its name, the README category it sits under, and what its README entry says it does. Verify that no install command or feature is claimed unless the framework's own project page states it.

  • Run parallel agent changes in separate Git worktrees

    Give each session its own Git worktree and review diffs and pull request status beside the chat.

    View prompt
    In the LodyAI/Lody repo, start two sessions in the workspace <workspace-name> against the repository <owner/repo>, each with its own Git worktree and a different task <task-a> and <task-b>. Output the worktree and diff summary for each session. Verify that the two sessions show separate diffs in their own tabs.

  • Submit a missing Jev project through the Issue form

    Add a project to the catalog using the GitHub Issue template, not a pull request.

    View prompt
    Open the Awesome Jev project form at https://github.com/logicrw/awesome-jev-projects/issues/new?template=project.yml for the repository <repo-url>. Expected output: a created issue URL with the project details filled in. Verify that no pull request was opened for this submission.

  • Add a typed Resource to the Endo app for your own data

    Define one table and schema, then get an API, agent tools and live updates from it.

    View prompt
    In the longsurf-ai/endo repo, follow docs/architecture/resource.md to add a Resource for <my data type>, defined once as a Drizzle table and an Effect Schema. Expected output: the new resource exposed through the typed API and agent tools. Verify that an agent tool can read and write a record and that the change shows in the app.

  • Write a custom indicator in Tea

    Code your own indicator or condition in Tea using functions, loops, state, and collections.

    View prompt
    In the openchart repo, write a Tea indicator that computes <your logic> on the <symbol> chart. Expected output: a Tea source file that compiles and draws the indicator on the chart. Verify by loading it with `just desktop` and checking the values against a few bars you calculate by hand.

  • See what your funds really hold with look-through

    Break down fund holdings by country, sector, company and currency to find overlap.

    View prompt
    In the aurelio-finance repository, open the Look-through view for my positions and list the top three companies and top three countries by exposure. Verify that each figure matches the fund holdings shown in the app.

  • Export a Reading Report and cross-paper reading plan

    Save checkpoints and notes, then export Markdown reports that summarize your reading across papers.

    View prompt
    Using the papergraph-mcp repo and workspace <workspace path>, export a Reading Report and a Cross-Paper Reading Plan. Return both as Markdown files and check that each open question in the report appears in the workspace state.

  • Detect parking spaces in one image through the cloud API

    Send one lot photo to the Developer Cloud API and get space detections back.

    View prompt
    Using the Lot Vulture Developer Cloud API described in the repo lotvulture/lotvulture README, send the image <image_path> with the region coordinates <rois_json> to https://api.lotvulture.com/v1/detect using the API key in the environment variable <api_key_env>. Report the detection result for each region and verify that the number of results equals the number of regions sent.

  • Track Claude and Codex plan limits in the notch

    See your 5-hour and weekly Claude limits and Codex limits in small pills in the notch header.

    View prompt
    Using the Louis-CFM/coucou repo, enable the Claude and Codex plan usage pills in the Coucou Mac app on <target Mac>. Expected output: the notch header shows a Claude pill with 5-hour and weekly limits and a Codex pill with its limits. Verify that the pills match the limits shown in your Claude and Codex accounts.

  • Ask for approval before risky shell commands

    Add tools.rules so an agent prompts only for matching bash commands such as rm.

    View prompt
    Using the repo lploc94/raw-cli, add an ordered tools.rules entry to the agent <agent-name> that asks before any bash command containing rm, then run it with the task "List files in <folder>" and "Remove <file>". Expected output: the list runs and the removal triggers an approval prompt. Verify the prompt appears and the -y flag does not skip it.

  • See where a modeling project stands and what needs your sign-off

    Get a status report of stages, evidence problems and pending confirmations.

    View prompt
    Use the Modeling Workbench repo in <tool folder> to check the status of the project in <project folder>. Run the project status tool, list the evidence problems and pending confirmations, and do not record any decision unless I confirm it in my own words.

  • Review the stages of a recorded DSH session by turn

    Classifies complete recorded model steps on request and links stages to their original trajectory evidence.

    View prompt
    Using the repo luobosibing2/dsh-jev-plugin, turn on Stage navigation in a DSH profile named jev, then classify the completed turns of the session <target session id>. Report the stage labels per turn and confirm the original session records are unchanged. Verify that tool arguments shown in the classification input are redacted.

  • Benchmark AgentJev serving latency on your load

    Run the repository's serving benchmark to see case latency and throughput on your own GPU.

    View prompt
    In the agent-jev repository at <repo-path>, run `python -m jev_service.benchmark_serving` on this machine and report P50 case latency, P90 case latency, and throughput. Verify that the run used the same checkpoint you plan to deploy.

  • Install Lyapunov on Linux and open a local workspace

    Run the published installer, confirm the launcher, and open a guest workspace without an account.

    View prompt
    Using the ManfredCh/Lyapunov repo, install Lyapunov on this Linux x64 machine with the published installer, then confirm that the launcher exists at $HOME/.local/bin/lyapunov. Report whether the installer reported ready and whether the native physics check passed. Verify the launcher path before starting the app.

  • Save typed decisions in an Eloquent JSON column

    Cast a model attribute to a decision class so the result reads back as a typed object.

    View prompt
    In the marcreichel/laya-php repo, add an AsDecision cast for <decision class> on the <model> model's <json column>. Save one decision, reload the model and report the stored JSON and the read-back enum value. Verify that assigning a non-decision value throws InvalidDecisionCastException.

  • Let trusted contacts' agents ask for access

    Set tiers and plain-English grants so a partner's agent can read your calendar.

    View prompt
    In the open-instinct repo at <repo path>, read docs/PERMISSIONS.md and docs/PROTOCOL.md, then list the seven tiers and how a grant is written. Expected output: a short list of the tiers and one example grant. Verify that a stranger's request is answered with a no in the summary you produce.

  • Watch site health and triage errors automatically

    A Web Dev Employee checks site health, triages errors and reviews dependencies on a schedule.

    View prompt
    Using the ai-employees repo, install the Web Dev Employee into <target folder> and confirm its health and error routines are scheduled. Expected output: a health report, a triaged error list and any branch changes. Verify that changes stay on a branch until you review them.

  • Compare token cost and response speed from past dsh sessions

    Open Model analysis to see tokens, estimated cost, timing, and retries by session or date range.

    View prompt
    Use the Model analysis page of the Mars-Sea/dsh-commandcode-provider plugin to summarize tokens, estimated cost, and response timing for the last <number> days. Expected output: a short table per model with the limits and missing data noted. Verify that the estimates are labeled as estimates from current prices, not invoices.

  • Send work from Claude Code on your laptop to the farm

    Connect Claude Code on your laptop to the farm and start its sub-agents without leaving your editor.

    View prompt
    Connect Claude Code to the clodfarm MCP server at http://localhost:8080/mcp using `claude mcp add --transport http --scope user farm http://localhost:8080/mcp`, then sign in with `/mcp`. Hand off the task <task description> to the farm and report the sub-agent it starts and its status.

  • Hand the Ciele install to a coding agent

    Let an agent clone, bootstrap, and verify a Ciele instance and report back.

    View prompt
    Clone the ciele repository from <repository URL> onto <target machine>, run ./deploy/bootstrap.sh, and report the app URL and any failed step. Verify that the app returns a response at that URL before reporting success.

  • Find deepening opportunities in an aging codebase

    Scan a repo for modules to deepen, review an HTML report, then grill through one pick.

    View prompt
    In the mattpocock/skills repo, run improve-codebase-architecture on <repo path>. Expected output: an HTML report of deepening candidates, then a grilling session on the one I pick. Verify that the report lists concrete modules rather than general advice.

  • Check a Room migration against data-layer traps

    Have an agent review schema changes and migration SQL against the data-layer trap index.

    View prompt
    Using the data-layer-footguns skill from kotlin-footguns, review the Room migration in <migration file path> and its schema diff. Expected output: each matched migration trap with the SQL line that triggers it and the verification result. Verify that each verification command you run appears verbatim in the matched trap file.

  • Move your MemoraX setup to a second device

    Connect a new machine to your MemoraX account by entering the saved username and API key locally.

    View prompt
    On this machine, run `memorax-code status` from the <project path> directory and report the status of each detected client integration. Do not print, copy, or move the API key. Verify that the output shows whether each Hook runtime is observed or unverified.

  • Approve purchases from your Link wallet

    Connect Stripe Link so the assistant can buy things you approve from your own wallet.

    View prompt
    Using the repo Merit-Systems/OpenInstinct, configure the Link environment variables for the project <your-app> without committing any secret. Expected output: a redeployed app with the Link wallet page showing the callback URL. Verify that STRIPE_PUBLISHABLE_KEY starts with pk_ and not sk_.

  • Reproduce the AppWorld evaluation with the dedicated setup

    Run AppWorld rollouts through the included mini-SWE-agent and environment to match the reported setup.

    View prompt
    Using the repo metaevo-ai/harness-zero, follow envs/appworld/README.md to run AppWorld test_normal rollouts with the dedicated agent and environment. Expected output: SGC scores across the 168 test tasks. Verify that the run uses the dedicated environment and not a generic harness before reporting scores.

  • Add this as the last pass after another writing skill

    Chain the skill after a drafting tool, reusing an existing claim-evidence map.

    View prompt
    The draft in <path to manuscript> is already polished. Use the game-the-llm-reviewer skill from Michael-Jiahao-Zhang/game-the-llm-reviewer as the final pass, reusing the attached claim-evidence map at <path to map>. Keep the meaning and scientific assessment unchanged, skip style-only rewrites, and return a revised copy and change note. Verify that every claim in the map still matches the revised text.

  • Have Jevry play and win a 2048 game

    Ask Jevry to play a supported numeric puzzle game in the browser and report the final board state.

    View prompt
    Use the repo michaelswissa/jevry: run npm run dev, then ask the desktop app to play and win the 2048 game at <game-url>. Expect a win message with a score and move count; verify the win state appears on the visible game board.

  • Score the describer and builder with the eval suite

    Run the fixture-based evals to check how well a Skill generalizes from one recording.

    View prompt
    Use the microsoft/skill-recorder repo to run the builder eval after my change to <file>. Expected output: scores for skill and automation generalization compared with the previous revision. Verify that the score for terminal redaction did not drop.

  • Check which pasted screenshot a prompt refers to

    Hover a pasted [Image #N] tag to see the picture while you write or review prompts.

    View prompt
    In Claude Code with the better-claude image-preview plugin installed, paste two screenshots into a prompt that refers to [Image #1] and [Image #2]. Expected output: hovering each tag shows the matching picture. Verify that each tag shows the correct image before sending.

  • Set up and debloat a TV with one Claude Code prompt

    Let Claude Code find your TV, debloat it, build the home screen and write a restore script from one prompt.

    View prompt
    Inside the cloned tv-home repo, follow PROMPT.md to find the Android TV at <tv-ip> over ADB, disable bloat reversibly without uninstalling, and install the launcher. Report the list of disabled packages, the launcher install result and the path to the restore script. Verify with a screenshot from the TV that the new home screen is showing.

  • Verify the exact CSV bytes behind a paired statistics run

    Retrieve the retained input file and provenance record for a paired statistics analysis in FOREST.

    View prompt
    Using the FOREST API on <base URL>, fetch run <run ID> for project <project ID>, download its retained paired-input.csv, and compute the SHA-256 of the downloaded bytes. Report whether it matches the input_provenance hash in the run record. Verify that the downloaded path is runs/<run ID>/paired-input.csv.

  • Follow one project folder across every agent

    Point a work group at a project folder to see which agents worked there and in what order.

    View prompt
    Using the agentacct repo at https://github.com/mikehasa/agentacct, open the Work group for the folder <project path> and list the agents that worked there and their most recent sessions. Verify that group totals are shown as sums of the participating sessions, with partial coverage labeled.

  • Install GoLive into an OpenClaw workspace

    Add the skill to a project's skills folder through ClawHub and keep it updated there.

    View prompt
    In the workspace <workspace-path>, install the golive skill from ClawHub and confirm that .clawhub/lock.json records it. Report the installed skill path and stop before connecting any provider account.

  • Hear overnight bot results read aloud

    Turn on spoken replies so a bot reads its answers as they land, using a voice you pick.

    View prompt
    Using the OpenMausBot repo at github.com/milind-soni/OpenMausBot, set the voice for the bot <bot-name> to <voice-provider> and read one reply aloud. Expected output: confirmation that the reply was spoken and which voice was used. Verify that the provider key is shown only as a configured flag.

  • Check a UI for contrast, focus, and mobile layout

    Use the accessibility and responsive skills to review a UI before release.

    View prompt
    Review the UI in <project-folder> against the antislop-human and antislop-layoutmobile skills from the anti-slop repo (https://github.com/miqdadbadjuber/anti-slop). Return a numbered list of contrast, focus, and overflow findings with the Delivery Gate report. Verify that each contrast finding names the ratio it measured.

  • Decode renderer RGB preview faster with TAEHV

    Attach the TAEHV decoder to speed up RGB output while encoding stays on the Wan encoder.

    View prompt
    Using the AgentGarten repo at <repo path>, add the TAEHV decoder override for the file at <taew2_2_super.pth path> and render the validation clips. Expected output: the same comparison videos under samples/, with RGB decoded through the TAEHV decoder. Verify that the decoder path in the override exists on disk before reporting success.

  • Submit a new case or skill to the benchmark

    Draft a new world, action, or probe case, or a new evaluation skill, in the existing benchmark format for submission.

    View prompt
    Read the HarnessEval-W repo and its public benchmark format, then draft a new <case or skill> for <the failure you want to test>. Expect a written draft with the world, action, probe intent, and sub-questions in the existing format. Check that the draft matches the format of the bundled examples before submitting it on the contribute page.

  • Port a Flutter app layout to iPhone Duo

    Adapt a Flutter app using the layout reasoning and the bridge guidance in the Flutter skill.

    View prompt
    Using the iphone-duo-flutter and iphone-duo-design-review skills from mirzaaghazadeh/iphone-duo-skills, review <path-to-flutter-project> for code that relies on MediaQuery.displayFeatures or other fold data. Output a list of what works now in Flutter and what needs a platform channel, and verify that no suggested fix depends on displayFeatures returning fold data on iOS.

  • Audit what an agent run actually did

    Check the patch, logs, and cleanup record for a finished run.

    View prompt
    In the ESF repo at <esf_path>, gather the output of `./bin/factory describe run <RUN_ID>` and `./bin/factory logs <RUN_ID>`. Report the patch, the gate results, and whether cleanup is recorded as verified, and verify that the patch matches the task before concluding.

  • Set cross-backend subagent delegation in Codex

    Choose between Compatibility V1 and Native subagent delegation for Codex tasks.

    View prompt
    Using the codex-chatgpt-web repo, run the subagents status command and report the current protocol. Then set the protocol to <compatibility-v1 or native> and confirm the new value by running status again. Expected output is the two status results and a note to restart Codex.

  • Audit shell scripts for hidden effects on the machine

    Flag scripts that download and run code, read secrets or install persistence.

    View prompt
    In the repository <repo-path>, with TYPESAFE_API_KEY set, run `npx jev-lint check scripts --dry-run` to confirm what would be sent, then `npx jev-lint check scripts`. List findings on .sh, .bash or .zsh files with their rule ids, and flag any that a human should read before running the script.

  • Serve Laya over HTTP for internal apps

    Run a local Laya HTTP service that other internal tools can call.

    View prompt
    In the laya-mlx repo (github.com/mizorewww/laya-mlx), install the serve extra and start laya-mlx-serve on this Mac. Find the request format in the upstream Laya documentation and send one choice question. Verify that the service returns an answers field with probabilities for the named options.

  • Index a local docs folder and search it from the chat

    Add a local file or folder to the FTS5 knowledge base and query it later.

    View prompt
    Index the folder <docs-path> with the context-mode ctx-index command, then search it with ctx-search for <question>. Return the matching passages with their source file names and confirm that each passage appears in the original file.

  • Track today's Digikala deals and bestsellers

    Get a daily list of current deals and site-wide bestsellers from Digikala.

    View prompt
    Use the Digikala MCP server at https://digikala-mcp.mmdju.workers.dev/mcp. Call incredible_offers and best_selling, then return today's deals and bestsellers with prices in Toman and product URLs. Verify that each deal line includes a URL the user can open.

  • Write screening rules in plain English

    Describe the signals you want in one sentence and let the agent compile them into a strategy.

    View prompt
    Using the noraz-agent repo, set a Custom Prompt strategy describing <your-screening-rule> and start the bot with `noraz run`. Expected output: a compiled strategy file or a logged fallback to the safe default. Verify that the 80% confidence gate and security gates are still listed as mandatory before reporting the setup as complete.

  • Generate an Apify actor endpoint from its input schema

    Scaffold a static zod input schema for an Apify actor and review it before committing.

    View prompt
    In the monid repo with APIFY_CREDENTIALS_API_KEY set, run deno task apify:scaffold for <actor name>, then review the generated schema/inputs.ts. Report any fields you would change before committing and whether deno task check passes.

  • Run a suspicious sample in an automated sandbox

    Use CAPE Sandbox to record behavior and payloads from a malware sample.

    View prompt
    Using the morluto/awesome-reverse-engineering list, outline a sandbox workflow for <sample-file> that uses only tools in its Malware analysis section. Expected output: a checklist covering isolation, submission, and report review. Verify that the checklist starts with an isolated virtual machine requirement.

  • Pull a multi-round AI portrait edit back to its root

    Remove accumulated color drift, noise, and seams after repeated AI edits by comparing against the first source.

    View prompt
    Use the xxg-portrait-rebuild-light skill from moskoo/xxg-portrait-rebuild-light to run a Q5 consolidation on <path to latest edit>, using <path to root source image> as the root base. Return one consolidated image, and verify that identity and unchanged colors match the root while the banding and seams are gone.

  • Build Nami from source to test or contribute

    Clone the repo, install dependencies and start the app locally to test changes before you contribute.

    View prompt
    Using the Nami repo at mrdainami/nami, clone it, run npm install and npm start, then report whether the desktop app opens. Expected output: a running local Nami window. Verify the install finished without errors before starting the app.

  • Schedule and publish approved posts to your own social accounts

    Connect your accounts, approve drafts in the studio, and let the scheduler publish them on time.

    View prompt
    Using the yominpost repo at github.com/mrlong0129/yominpost, start the studio, connect <platform name> with its OAuth client, and schedule the approved draft <draft id> for a time you set. Expected output: the post in the scheduled queue with a status. Verify that a person approved the post in the UI before it was published.

  • Combine a vision model with local OCR for exact clicks

    Use your own vision model for meaning and local OCR for pixel-precise coordinates on screen.

    View prompt
    Use the nuphus-mcp desktop_vision tool to describe where the <target label> button is on screen, then use desktop_perceive to find its exact coordinates. Click it and return a screenshot path. Verify the screenshot shows the expected change before you report success.

  • Read the charter to draft an internal AI policy

    Use the charter sections as a checklist when drafting a company's own AI governance policy.

    View prompt
    Using the Universal AI Charter at https://mrtinkz.github.io/ai-charter/charter, compare its six sections against this policy document: <policy file>. Expected output: a table of charter principles marked as covered or missing in the policy. Verify that each principle you cite appears on the charter page.

  • Show LaTeX formulas as typeset images in Claude Code

    Install RaTeX's renderer, turn on latex, and draw display math as images in kitty or Ghostty.

    View prompt
    On this machine, download the RaTeX ratex-cli archive for <platform>, install the file as ratex-render on the PATH, set the prismantis latex option to true, then run /reload in Claude Code. Expected output: a display formula drawn as an image. Verify that the test formula comes back and that the formula's copy button copies LaTeX text.

  • Choose the correct credential value without exposing it

    List variable names, then review ranked candidate values in masked form.

    View prompt
    In the session-knowledge repo, call list_credentials to find the variable name for <service>, then call get_credential in masked form only. Expect ranked candidates with their call sites and no plaintext shown. Verify that the chosen candidate is not a documentation example before using it.

  • Rebuild a rough draft from its facts and intent

    Rewrite a flat draft from its source facts and stated purpose instead of editing it.

    View prompt
    Using the sepia repo, run its recreate operation on <facts and intent file>. Expected output: a full rewrite that keeps only the facts and intent from the source. Verify that every number and name in the rewrite appears in the source file.

  • Set routines and goals that run while the app is closed

    Ask the agent to check a goal on a schedule and to write a feed for you each morning.

    View prompt
    In the nano-muse/nanoMuse repository, use the signed-in app on <device> to set one scheduled goal and one morning feed. Report the goal and schedule the agent confirms, and verify the first run completes after the app is closed.

  • Check a scroll page for dead scroll and unreadable text

    Run the headless verification pass to find dead scroll, faded cues, and low-contrast lines.

    View prompt
    Using the scroll-craft verification tools in the nateherkai/scroll-craft repo, check the built page at <page path> at every scroll position. Expected output: a report listing dead scroll, faded cues, contrast failures per line, and any video leg stuck on a poster frame, plus a contact sheet. Verify that every reported contrast failure is listed with its line of copy.

  • Gate agent handoffs on a test command Foremerge runs

    Register a trusted check so work counts as done only after Foremerge runs it itself.

    View prompt
    In the <repo path> repository, register one check with `foremerge checks set` using the repository's real test command, then run `foremerge doctor`. Expected output: a doctor report stating whether the check can run in this worktree. Verify that the check does not always pass before you rely on it as a gate.

  • Recover GPT with Taste after a broken or changed install

    Restore the managed Codex files using the recovery guide.

    View prompt
    In the gpt-with-taste checkout at <repo-path>, follow docs/recovery.md to restore the managed state under the active CODEX_HOME. Report which files were restored and confirm that model_instructions_file points to the main managed prompt file.

  • Run unattended scans across several repositories

    Use the vulnhunter-run operator to clone, hunt, and record results without manual steps.

    View prompt
    Using the VulnHunter repo at nealbridges/VulnHunter, run the vulnhunter-run operator on the repositories <repo list>. Return the scan manifest and the results location for each repository. Verify that the manifest passes validation and that the operator stopped at its explicit stop rules where a repository could not be cloned or scanned.

  • Run the experimental 125B Flash model from disk

    Load Qwen3.8 Flash, which keeps most of its experts on disk, in one Chrome tab and speed it up by joining a second PC.

    View prompt
    In the Nehanth/pooled repository, open a room in Chrome, select Qwen3.8 Flash, accept the roughly 99 GB storage prompt, and send 'Hi'. Expected output: a reply after a few seconds on a single machine. Verify that the room shows the model as loaded and the reply uses the 64K context setting.

  • Let an agent route its next work phase via skill

    Link the model-router skill so an agent can route the next phase of your work through the router.

    View prompt
    Using the model-router skill from the agent-router repo, route the next phase of the plan at <plan path> and report which agent, model, and effort the router selected. Verify that the router decision card appears in the output before any work starts.

  • Run an agent on a local model with Ollama or LM Studio

    Connect an agent to a local model server so prompts stay on your machine.

    View prompt
    In the nightly-labs/openbot repo, connect the desktop app to the local model server at <endpoint-url> and create an agent that uses it. Expected output: one test reply from the agent in its conversation. Verify the reply came from the local server before reporting success.

  • Check a course fork's build and contrast before publishing

    Have an agent run lint and build and review the contrast rules before release.

    View prompt
    In the NiluK/worldmodels101 fork at <path>, run `pnpm lint` and `pnpm build`, then compare any changed text colours against the contrast notes at the top of src/app/globals.css. Output a pass or fail for each check and list any text token that may fall below WCAG AA.

  • Add a pass or fail review check to pull requests

    Run the adversarial reviewer and tamper guard as a GitHub Action on each pull request.

    View prompt
    In the repo <owner/repo>, add the no_human review-gate workflow with a pinned reviewed commit SHA and the secret ANTHROPIC_API_KEY. Open a test pull request and report the checklist comment and the exit status, and confirm the head SHA checkout is set.

  • Run and test Cozy Clay from source for contributions

    Clone the repo, install dependencies, start the dev server, and run the test suite.

    View prompt
    Using the NomaDamas/CozyClay repo, clone it, run `npm install`, `npm run dev`, and `npm test`, then report the test result. Expected output is a passing test run and the studio running at http://127.0.0.1:5180/app/. Verify that AGENTS.md has been read before any code change is proposed.

  • Find subscriptions and what they cost per year

    Run the subscription-audit prompt to list recurring payments and their yearly cost.

    View prompt
    Using the repo noskillish/bankmcp, run the subscription-audit prompt on the account labelled <account label>. Expected output: a list of recurring charges with yearly cost for each. Verify one charge against the matching line in get_transactions.

  • Find a shared skeleton across a series of drafts

    Scan several recent pieces so a new draft does not repeat the shape of the last three.

    View prompt
    Using the humanizer-stack repo at <repo path>, run structural_scan.py on each file in <series folder> and compare the results for audit 6, shape convergence. Output a short table of the shared patterns and one suggested shape for <new draft file> that differs from them. Verify that the suggestion changes at least one structural choice and does not add a new fixed template.

  • Switch Ever Room's Agent to a real model provider

    Set the Pi runtime and provider variables so the Agent uses a real model instead of the fake runtime.

    View prompt
    Using the EverRoom repository at <repo path>, read the Run with a real Agent model section of README.md and list the environment variables needed for the Pi runtime. Output them as a dotenv template with empty values for secrets. Verify that no real API key is written into the output.

  • Run a local OpenAI-style audio API for an app

    Point an OpenAI audio client at a local speech server for speech and transcription.

    View prompt
    In the nyosegawa/speech.cpp repo, install speech, run `speech serve qwen3-tts-0.6b qwen3-asr-0.6b`, and then call the local POST /v1/audio/transcriptions endpoint on 127.0.0.1:8080 with a WAVE file at <path>. Expected output: a JSON or text transcript of the file. Verify that the text matches the audio.

  • Find out why an agent session went wrong

    Have the agent review a session transcript for skill failures and optionally package a bug report.

    View prompt
    Using the diagnosing-superpowers skill from the obra/superpowers repo, review the session <session name or 'this session'> and report what went wrong with superpowers. Expected output: a report with line-level evidence and an offer to package a scrubbed bundle. Verify that each finding cites a specific point in the transcript.

  • Measure token and latency savings on a local model

    Run the bundled benchmark suite to check the claimed token reduction on your own hardware.

    View prompt
    Using the okf-memory/okf-agent-memory repo, run the make benchmark target against the local model server at <endpoint>. Report time-to-first-token and token counts for the run and compare them with the README's claimed reduction. Verify that the benchmark used the local model and not a remote API.

  • Read a washer's minutes-left display into Home Assistant

    Turn a appliance display's remaining minutes into a sensor you can automate on.

    View prompt
    Using the VisionState repo at https://github.com/oleost/VisionState, create a reading sensor for the camera <camera_entity> that reads the minutes-left display on <appliance>. Expected output: a numeric sensor that matches the display. Verify that the sensor value matches the display on three separate checks.

  • Have an AI agent design a System One workflow

    Install TypeSafe's agent skill files so Claude Code or Codex can draft a typed System One workflow.

    View prompt
    Using the skill files in https://github.com/typesafe-ai/skills, design a System One workflow for <decision task> using the Choice, Score or Noul primitive. Output the typed question and the fixed option set. Verify that every option is listed and that the output asks for a probability per option.

  • Fine-tune One Jev on your own labeled questions

    Train a checkpoint on your own media and typed questions using the repo's config files.

    View prompt
    Using the OneJev repo at https://github.com/OmniJev/OneJev, install with `pip install -e ".[train]"` and run the 100-example demo unpack step. Report the path to train/configs/onejev_4b_full.yaml and the number of lines in data/onejev/train.jsonl. Verify that data/onejev/media/ exists before you start training.

  • Reframe, fix, and upscale a reference image inside Blender

    Use built-in image tools to crop, repair transparency, correct perspective, and enlarge a reference.

    View prompt
    Using the OmooLab/AnyImage add-on in Blender, apply the image tool <tool name> to the Image Empty <image empty name>. Expected output: an edited image in the scene. Verify the edit visually in the 3D View and confirm the source image is unchanged where required.

  • Edit the planner and actor prompts for a custom workflow

    Change the plain-text prompts in the repo and rebuild the app to tune how the agent behaves.

    View prompt
    Using the repo onehumanbeing/esp32-iphone-agent, read the planner and actor prompts in prompts/ and propose one edit for <target app or workflow>. Expected output: the changed prompt text as a diff. Verify that the edit keeps the existing action names so the app still parses the model reply.

  • Skim Hacker News top stories in a few hundred tokens

    Open the Hacker News front page as a numbered list and drill into one story.

    View prompt
    Use the only-cli/oc repo: run `oc hn top` to list current top stories. Expect a numbered list of headlines. Verify the list has entries before picking one to open with `oc do <n>`.

  • Add a new model provider with a wire capture

    Probe a provider's API, attach the capture to a pull request, and pass the repo's contract tests.

    View prompt
    Using the OnlyTerp/opengrok repo, run `python tools/wire-probe.py` against <provider-base-url> with model <model-id> and key from the environment variable <KEY_ENV_NAME>. Report the verdict and the path of the saved capture. Verify both `node tools/test-provider-maps.cjs` and `node tools/test-provider-maps-hop.cjs` pass before reporting the map as ready.

  • Check a film for errors before publishing it

    Use the look command to find changed frames, page errors and cut-off text.

    View prompt
    In the openfilm/openfilm repo, run `openfilm look` on the film at <folder> and list every reported problem. Expect a contact sheet and a report that names any changed frames, page errors, fonts that failed to load, missing sound files and cut-off text. Verify by fixing one reported problem and running `openfilm look` again to confirm it is gone.

  • Run the demo personal agent chat UI locally

    Start the demo personal agent with its JWKS server and chat UI on your machine.

    View prompt
    Using the openpactprotocol/openpactprotocol repo, start the demo personal agent in reference/personal-agent/ and report the local URL of its chat UI and of its JWKS endpoint. Verify that the JWKS endpoint returns a JSON key set before you report success.

  • Find PRD gaps and conflicts before anyone writes code

    Get one P0/P1 register of gaps and conflicts from a PRD, with verification steps.

    View prompt
    Use codexqa-requirement-analyzer on the PRD at <prd-path>. Produce one P0/P1 gap-and-conflict register, with preconditions, stimulus, expected result, and evidence for each high-priority row. Verify that every high-priority row has an executable verification step.

  • Add a GitHub scanner to your review after approval

    Configure a compatible scanner from GitHub, approve it, and run it in your reviews.

    View prompt
    In the repo at <path>, add the Bearer scanner from https://github.com/Bearer/bearer as a custom scanner in .openqodex/config.yaml. Do not run `openqodex trust` until I approve; then run `npx openqodex scan --only custom:bearer` and report whether it produced findings.

  • Let Claude Code hand coding tasks to Pi Bolt

    Register Pi Bolt as an MCP server so Claude Code can send it prompts.

    View prompt
    In the repo opensec-material opensec-git/Pi-Bolt, register pi-bolt as a Claude Code MCP server with the full executable path and the --mcp argument. Send a short task through the prompt tool and report the reply. Verify that a second prompt call continues the same session.

  • Send unmatched commands to a local model

    Point sparx at a llama-server you run yourself so unmatched phrases reach a local model.

    View prompt
    Using the repo OpenSparX/MasterAgent, start a local llama-server with <your GGUF model>, then run `sparx run --endpoint 127.0.0.1:8080 --model local --input '<phrase>'`. Expected output is either a validated tool result or an error. Verify that a phrase asking for an unknown tool returns an error, not a tool call.

  • Add an avatar to a LiveKit voice agent

    Attach an avatar to your AgentSession so it plays in your normal LiveKit frontend.

    View prompt
    Use the openspline repo (github.com/openspline/openspline) to attach an AvatarSession to the LiveKit agent in <path-to-agent>, using portrait <path-to-portrait.jpg>. Start the avatar before agent_session.start and confirm the avatar is visible in the room.

  • Build a local knowledge base for team reference

    Put team documents into a local knowledge base the agent can use in later tasks.

    View prompt
    Use the Open Vetta repo (openvetta/open-vetta) to create a local knowledge base from the files in <document-folder>. Ask it one question that only those files can answer and report the answer and the file it came from. Verify the answer against the source file by reading that file directly.

  • Look up companies, people and work emails for sales

    Ask bots to research companies, contacts, hiring and funding news, and local businesses for outreach.

    View prompt
    Using the OrgoAI/bops repo, describe how a user asks the bot team to research <company-name> and list the data types it can return, such as company, people, work emails, phones, news, hiring and funding. Expected output is a short list of those data types and which lookups require user approval. Verify each data type against the README's lookup section before reporting.

  • Build a debug Android APK from source

    Compile the Community Edition Android client into a debug APK with Gradle.

    View prompt
    In the oriveo/oriveo repository, change into android and run ./gradlew :app:assembleDebug with JDK 21 and the Android SDK available. Expected output: a debug APK in the app build output. Verify that the build finishes with no errors and report the APK path.

  • Sign in to a site and read back the account page

    Have Scout log in with your details and report what the account page says.

    View prompt
    Use the outcrawl/scout repo to build task.ts that signs in to <site URL> using the credentials in environment variables and reads the welcome message on the account page. Print result.data and result.replayUrl. Verify that result.status is completed and that the replay shows the signed-in account page.

  • Trace how refusal directions are ablated across layers

    Run Heretic from a source clone to study its per-layer residual directions and ablation kernel settings.

    View prompt
    Clone the p-e-w/heretic repo, run `uv run heretic <model-id>` from the repo root, and wait for the optimization to finish. Return the chosen direction_index and the per-component weight parameters, and verify that each value falls within the ranges the run reports.

  • Run a bot that reacts to Bilibili live room events

    Connect the Bilibili World to answer danmaku, superchats, gifts and guards in a live room.

    View prompt
    In the Cortico repo at <path>, enable the bilibili World for the default deployment and confirm that a test danmaku event reaches the bot. Expected output: a logged event and a bot reply. Verify that credentials are stored only in local configuration and not in committed files.

  • Prototype an articulated assembly and export URDF

    Describe a multi-part mechanism and get a generated assembly with a URDF file for simulation work.

    View prompt
    Use the Multi-Agent-CAD repo (github.com/Pan-Chera/Multi-Agent-CAD). Follow mac_assembly/README.md to generate an assembly from the mechanism description <mechanism description> and export URDF. Report the URDF path and list the joints, then check that each joint limit matches the brief.

  • Host your own Shared Sessions room server

    Deploy a Cloudflare Worker or Node server so your team keeps rooms on its own infrastructure.

    View prompt
    In the Paradigm-Study/claude-share repo, run the setup script to deploy a room server to <cloudflare-account> and point the plugin at it. Output the server URL and the result of the check command. Verify that a temporary session shares and joins through that URL without touching the public default server.

  • Load test an LLM endpoint past 1000 concurrent requests

    Use guidellm to sweep concurrency and report p50, p95, and p99 latency.

    View prompt
    Using the patchy631/time-to-first-token repo, run a guidellm concurrency sweep against the endpoint at <server URL> up to 1000 concurrent requests. Expected output: p50, p95, and p99 latency at each concurrency level. Verify that the results from a second load tool agree with guidellm within a reasonable margin.

  • Chat with your Mac's bots from your phone

    Pair your iPhone with your Mac through Noodle Hub settings to talk to your own bots.

    View prompt
    Using the Noodle repo at github.com/pdparchitect/noodle, pair an iPhone with a Mac running Noodle and send a test message to <bot name>. Expected output: the bot replies in Noodle Mobile. Verify that the Mac is awake and that the phone shows the Mac as a Hub.

  • Watch agents and CPU load across several SSH hosts

    See each remote machine's agents, status dots, and CPU and memory in one client.

    View prompt
    Using the penso/herdr-gpui README, configure saved SSH hosts for <host-1> and <host-2> in the app and list the CPU, memory, and agent status shown for each host row. Verify that the status bar follows the host you selected.

  • Benchmark decode and prefill on your own box

    Reproduce the published throughput numbers on your own Strix Halo machine.

    View prompt
    Using the repo peonist-ai/halogen-flash-server, run the prefill and decode benchmarks described in docs/performance.md on <target machine>. Expected output: a table of prefill tok/s and decode tok/s for each prompt length and text type. Verify the host settings match docs/troubleshooting.md before comparing against the published 0.18.0 figures.

  • Rebuild and test SPACE changes with a Tilt loop

    Run tilt up to rebuild affected images and roll workloads as you edit SPACE files.

    View prompt
    In the perplexityai/SPACE repo, after local installation, run `tilt up` from the repository root, then run the Kind smoke suites described in infra/space/kind/README.md. Report which suites pass and fail. Verify that Tilt shows the workloads rolled after your edit.

  • Assemble an auditable industry report with verified evidence

    Combine chain, timeline, and company evidence into a report where each claim points to registered evidence.

    View prompt
    With the dsh-industry-research plugin in DeepSeek Harness, call industry_report for the industry <industry-name>, using the existing chain, timeline, and company artifacts. Expect report.md and manifest.json in the reports folder. Verify that every claim's evidence IDs exist and that the delivery contract passed with no placeholders.

  • Track claims that the evidence has disproven

    Query the ledger and the falsification log to see which claims the sources contradict.

    View prompt
    Use ledger_query from dsh-research-report on the claims in <report-dir>. Expected output: a list of contradicted and disproven claims with their reasons. Verify that each listed claim also appears in disconfirmation.jsonl before you report it.

  • Route Jev calls through an OpenRouter key

    Point the jevcore-dsh plugin at OpenRouter when a TypeSafe key is impractical.

    View prompt
    In the PerryLink/jevcore repo, configure the jevcore-dsh plugin with provider openrouter, openRouterApiKeyRef OPENROUTER_API_KEY, and model jev-latest. Expected output: a startup report naming the openrouter.ai endpoint. Verify that the report lists which state fields are sent before any live call is made.

  • Gate schema migrations in CI with a Postgres lint

    Fail a pull request when a schema change adds a critical finding, without a live production database.

    View prompt
    Use the pgbot tool from the pgrundev/pgbot repository in CI by running `pgbot inspect --profile=schema --fail-on=critical --format=sarif` against <ci-database-url>. Report the exit code and the number of findings in the SARIF output. Verify that exit code 3 is reported as a connection failure rather than as a finding.

  • Collect enquiries and newsletter sign-ups without cookies

    Add an enquiry form and double opt-in newsletter to a business site, then send confirmed subscribers to your mailing service.

    View prompt
    Using the kaletacms repository, set up the enquiry form and double opt-in newsletter on my Kaleta site at <site-url>. Expected output: a list of the form fields and the mailing service I connected, and verify by submitting one test enquiry and one test sign-up.

  • Produce reusable work files from attachments and Skills

    Combine attachments, knowledge, and a Skill to draft a document you can edit as Markdown.

    View prompt
    Using the Pinvou/pinvou-agent repo, attach <source-file> and a Skill to a Work session and ask the agent to write a <document type>. Expected output: an editable Markdown artifact in the artifact panel. Verify that you can edit one passage directly and that the change is saved.

  • Run the full check gate before handing off changes

    Run the project's checks and iteration gate on a local checkout before sending a change for review.

    View prompt
    In a checkout of plannotator/artifact-server, make the requested change to <file-or-feature>, then run pnpm check, pnpm test:web, and pnpm verify:iteration. Expected output: a pass or fail summary for each command and a list of any rule from AGENTS.md the change touches. Verify that all three commands exit successfully before reporting the change as ready.

  • Catch tests that pass against old code in CI

    Run every new test against the old code in CI and fail any test that passes there.

    View prompt
    In the repo at <repo-path>, after gap-trap setup, open a PR that adds one new test. Report the result of the proven red CI job for that PR. Verify that the job ran in CI and not only locally.

  • Run Roamgate from source to develop or test it

    Install dependencies with Bun and start the server and web app in separate terminals.

    View prompt
    Using the powerfooI/roamgate README, clone the repository and start the dev server and web app against a running Herdr server. Report the URL the web app prints and whether it loads. Verify the page responds before reporting success.

  • Cap memory and keep the GPU off on a shared machine

    Start Janas-LLM with a memory limit or without the GPU so it does not take over a shared computer.

    View prompt
    In the janas repo, run JANAS_GPU=0 ./janas-chat and ask one short question. Report the reply and confirm from the output that no GPU was used. Verify that the process ended cleanly after Ctrl-D.

  • Check what Jev robotics work is proven before building

    Separate running Jev robotics systems from author measurements and design-stage ideas.

    View prompt
    Using the Promethe-us/awesome-jev README and docs/ROBOTICS.md, produce a table of Jev robotics items for <my robot platform> labeled running, author-measured, or design-stage, with source links. Verify that no ROBOTIS brand integration is stated as confirmed.

  • Review a 'done' claim against its evidence

    Use Chapter 9 and Lab 003 to match each claim to the evidence that supports it.

    View prompt
    In the Prysai-LLM-Playbook repository, use book/chapters/09-verification-and-recovery-EN.md and Lab 003 to review the completion claims in <report> against the files in <target>. The expected output is a claim-to-evidence table with unproven items marked. Verify that each accepted claim points to a file, test, or output you actually inspected.

  • Check Vision HOPE accuracy on ImageNet, COCO, or ADE20K

    Run the matching test script on your downloaded dataset to measure a released checkpoint.

    View prompt
    Using the VisionHOPE repo (PSRben/VisionHOPE), run scripts/test/visionhope_small.sh on the dataset at <dataset path> with checkpoint weights/visionhope_small.pth. Report the evaluation metrics and compare them with the Main results section of the README. Verify that the dataset folders match the layout in the Datasets section before the run starts.

  • Inspect, self-host, and contribute to Ptero's code

    Read the GPL v2 source, run your own copy, and submit a pull request following the project style.

    View prompt
    Using the Ptero repo (Ptero-ai/Ptero), clone the code, locate the plugin files that handle the chat interface, and summarize <focus area> in a short report. Expected output: a list of files with one sentence on each. Verify that the file paths you cite exist in the cloned repository.

  • Start a new project from a spec blueprint

    Create a board from a bundled blueprint for your kind of project, so the rules and starter items are ready.

    View prompt
    In an empty git repo <path>, run `npx pullboard init --blueprint web-app` and list the spec rows and starter items it created. Report which rows are still drafts that need your approval. Verify that the rows are marked draft until approved.

  • Connect a remote MCP server in Claude.ai or ChatGPT

    Add a hosted MCP URL under Settings → Connectors without touching code.

    View prompt
    Using the repo awesome-remote-mcp-servers, add the URL <server-url> under Settings → Connectors in my chat app, then ask it to <task>. Expected output: a reply that uses the connected server. Verify the connector shows as active before testing.

  • Run the agent on a server and drive it from a laptop

    Serve the DSCODE runtime from a server and attach a local terminal to it over a token.

    View prompt
    Using the repo qiz029/dscode, start the runtime on <server host> with `dscode server --port 8080`, attach with `dscode runtime devbox`, and report whether the terminal connects. Verify that files you open are read from the server, not from the local machine.

  • Build Pulse from source and run your own copy

    Clone the repo, build the app bundle with the included script, and launch it on your Mac.

    View prompt
    Clone https://github.com/qunqin24/Pulse into <target-folder>, run ./Scripts/bundle.sh from inside it, and confirm that build.noindex/Pulse.app exists. Report any build errors and the final lines of the build output.

  • Suggest a missing paper for the gallery

    Open an issue with a paper link so maintainers can add its Figure 1 to the gallery.

    View prompt
    Draft a Suggest a figure issue for the repo qwdwqfwq/topconf-paper-figure-gallery for the paper <paper title and URL>. Include the title, the paper link and the likely visual pattern. Verify that the paper is from one of the listed venues or is a new venue the README welcomes before submitting.

  • Run a voice frontend stack with local speech models

    Connect the Hugging Face speech-to-speech service so VAD, STT, LLM, and TTS run locally.

    View prompt
    Use the repo QwenAudio/qwen-audio-agent to connect the Hugging Face speech-to-speech frontend running at <service URL>. Report the frontend name shown in the Gateway and whether a spoken question gets a reply. Verify the Gateway log shows the local service URL before reporting success.

  • Check which services call which, and catch broken links

    Record each cross-service call once and fail when a client, handler, or endpoint moves.

    View prompt
    Using the repos at <repo paths>, write system.links.json describing the calls between services, then run vibeX links with --check. Report any broken client, handler, or endpoint, and list endpoints nothing calls. Verify the check fails when a handler is renamed in a test copy.

  • Clear developer caches without permanent deletion

    Measure build and package caches, see what each costs to lose, and move the ones you pick to the Trash.

    View prompt
    Using the Janus repo at RamitVishwakarma/Janus, list the developer cache directories Janus measures on this Mac and their sizes. Report which ones are greyed out because their app is running. Verify that nothing was deleted permanently by checking that cleared items appear in the Trash.

  • Test chat and speech on the device without a mic

    Run typed turns over serial to check the chat and TTS pipeline before a voice test.

    View prompt
    In the esp32-thinks repo, run python3 scripts/tts_probe.py <port> "hello?" against the flashed device and report the chat reply text and whether speech was produced. Verify that the probe finishes without a stall and that >status shows Wi-Fi and heap healthy.

  • Study the legacy WhatsApp Web protocol from a documented case

    Learn how a browser messaging session was paired, keyed and encrypted from a written case.

    View prompt
    Using the whatsapp-web-reveng case in the Awesome-REA README, explain the pairing, key setup and message encryption stages of the legacy WhatsApp Web protocol to a reader. Output a numbered summary with one paragraph per stage. Verify each claim against the linked repository before stating it.

  • Export a scan as robot-training data

    Turn a scanned space into a LeRobot or GR00T dataset, or an Isaac Sim or MuJoCo scene.

    View prompt
    Using the openreality MCP tools, export the scene <scene id> as robot-training data in the <format: LeRobot, GR00T, Isaac Sim, or MuJoCo> format and save the zip to <local path>. Verify that the zip exists locally and that the export format matches your request.

  • Announce a deploy to the whole team from your terminal

    Send one message to everyone on the network, or to a chosen group, sent from you and not from an agent.

    View prompt
    In the reason-machines/reason-network repo, run `reason-network who`, then send the message "<announcement>" to '*' or to a documented target such as repo:<name>. Expected output: a confirmation that the message was sent to the chosen audience. Verify that the audience matches who you intended by reviewing the `who` output first.

  • Export a fresh ONNX bundle from a newer Laya checkpoint

    Rebuild the ONNX bundle from the Hugging Face checkpoint and check it against PyTorch.

    View prompt
    In the receptron/laya repo, follow the export section of the README to build an ONNX bundle from convaiinnovations/laya into ../onnx. Expected output: the export script prints a max logit difference against PyTorch that is about 1e-5 and the five bundle files exist. Verify by running `LAYA_MODEL_DIR=./onnx yarn example` and confirming it completes.

  • Run the agent against crackme eval tiers

    Fetch the eval binaries, run the harness self-tests and execute an eval tier to measure the agent.

    View prompt
    In the Recurse repo at <repo path>, fetch the eval binaries, run the harness self-tests, then run the eval tier. Report the number of tasks that finished and the path of the run.log. Verify that the trace folder contains one JSON file per task.

  • Catch quality regressions before a task is marked done

    Run the quality delta check so only what got worse is reported.

    View prompt
    Use ripwire on the repo at <path>. After your changes, run the --quality-delta flag and list every quality kind that got worse. Verify each one by reading the flagged code before you fix it or record a reason to keep it.

  • Build Remocn Studio from source and run its tests

    Clone the repo, install dependencies, and run the app in development mode with the test suite.

    View prompt
    Clone the repo https://github.com/Remocn/remocn-studio into <target folder>, install dependencies with bun, and run the test suite. Expect bun run test to finish with a pass or a list of failing tests. Verify the result by reporting the exact test summary before editing any file.

  • Run a smaller or quantized model on modest hardware

    Pick a lighter model size or quantization to run decisions on a laptop with limited memory.

    View prompt
    In the rizzo-flow repo, run `uv run rizzo devices`, then start the server with `uv run rizzo serve --size 1.7b` and send the same three questions from <path-to-test-file> that were answered by the default model. Return the answers and probabilities side by side. Verify that accuracy differences are recorded before choosing a model.

  • Prepare a Flash-Next pack for the strata engine

    Build the pack directory and MTP draft directory once so the strata engine can serve Qwen3.8-Flash-Next.

    View prompt
    In the UnbiasedStrata repo at <repo-path>, prepare the Flash-Next pack from the GGUF shard at <gguf-path> and report the output directory and its file list. Verify that draft_vocab.bin is present in the MTP directory before reporting success.

  • Back up your Talorys data and restore it later

    Download a backup file of your data and import it into another install.

    View prompt
    In the Talorys app at <pages-dev-url>, download a backup from Settings > Privacy and save it as talorys-backup.json. Report the file size and the counts of conversations, memories and tasks if shown. Verify the file opens as valid JSON and contains an automations list.

  • Block replayed or altered agent write approvals

    Check role and path on agent tool calls, consume each approval once, and write an audit receipt.

    View prompt
    In the repo rohitg00/ai-engineering-from-scratch, run the tool-call-firewall project with --init into learning-artifacts/tool-call-firewall, then implement the stages until the --all --strict grader passes. Expected output: an audit receipt for each tool call with the policy decision. Verify that a replayed approval and an altered write are both rejected.

  • Command a robot from a Claude chat window

    Send a goal to one of your registered robots from Claude over MCP.

    View prompt
    Using the rokbenko/quackd repo, set up the MCP connection so Claude can reach quackd, then send the goal "Find the ball and kick it" to a robot registered as <robot-name>. Report what Claude returned and the final status. Verify that quackd applied the robot's skill list and step limit to the run.

  • Serve document extraction through a FastAPI endpoint

    Run the production FastAPI server so other systems can send documents and get fields back.

    View prompt
    In the py-idp repo, start the FastAPI server with `idp serve`, then send <path to document> to the /extract endpoint. Return the JSON response. Verify that /healthz returns a healthy status before you send the document.

  • Sort an inbox and draft replies for messages that need you

    Have Rome archive the noise, flag urgent mail, and draft replies that you review before sending.

    View prompt
    Using the rome-os/rome instance at http://localhost:7663, ask Rome to sort <mailbox-name>, archive routine mail, flag urgent messages, and draft replies for messages that need a human answer. Expected output: a list of archived, flagged, and drafted messages. Verify that no reply was sent without your review.

  • Script agent sessions through the loopback REST API

    Call the local session endpoints from scripts or CI to list sessions and send turns.

    View prompt
    Using the Grok App repo (https://github.com/RongleCat/grok-app), call the loopback session API to list sessions and post one turn to session <session-id> with the prompt <prompt-text>. Expected output: a successful response and a new turn in that session's timeline. Verify the session identifier against the GET /v1/sessions response before posting.

  • Check running sessions from a browser over HTTPS

    Enable the browser listener and use an access token to reach your sessions from another device.

    View prompt
    Using the RoversX/ThinkTerm repo, enable the browser listener in Settings and then Web, create an access token, and open the web client from <device>. Expected output: the list of running sessions on the mux server. Verify that the browser shows the same sessions as the desktop app.

  • Prepare a redacted Healthcheck summary to review

    Create a local summary file from a check report, inspect it, and validate it before choosing to send it.

    View prompt
    Using the AgentMeasure repo, run `agentmeasure check --json report.json`, then `agentmeasure share report.json --out summary.json`, then `agentmeasure validate summary.json`. Report whether validation passed and list the fields in summary.json. Verify that no upload happened and that report.json was not attached to any message.

  • Let Claude create a mission within limits you set

    Allow Claude to create a console mission with approval, then check it in Missions.

    View prompt
    Using the repo ruvnet/ruflo, have Claude create a mission with the goal <mission goal> in the Ruflo console with write and ask settings. Expected output: the mission in Missions with the goal text. Verify that the mission exists and that creating it did not mark the feature as implemented.

  • Create a set of product clips in one consistent style

    Write several clip prompts for one product that share lighting, grade and mood.

    View prompt
    Using the cinematic-video-prompt skill from the repo Rylaispirit/cinematic-video-prompt-skill, write three English video prompts for the product <product description>, sharing one style, color grading and mood block, each with a different single camera movement. Return them as three code blocks. Verify that the lighting and grading wording is identical across the three prompts.

  • Find paid queries you already rank for organically

    Compare Google Ads spend with Search Console rankings to find clicks you could get free.

    View prompt
    Using the open-seo-mcp-skills seo-vs-ads skill through the Ryze MCP, list queries that <target-domain> pays for on Google Ads and already ranks for organically in Google Search Console. Return each query with its ad cost and organic position. Verify that both the ad data and the organic positions come from connected accounts before you recommend any change.

  • Keep AI-made Roblox edits in git with Rojo

    Link a Rojo-synced place so agent edits save to project files and show in git diff.

    View prompt
    Using the Roqer repo at <repo path>, link the Rojo-synced place <place name> in Roqer, then ask the agent to make the change <change description>. Expected output: the changed script files in the Rojo project folder, visible in git diff. Verify that git diff shows the same change the agent reported.

  • Dictate text into any text field on your Mac

    Hold fn, speak, and release to type your words into the field you are using.

    View prompt
    Using the repo SaarthurR/atticus-mac, dictate a short sentence into a text field with the fn key in Verbatim mode. Expected output: the spoken sentence appears in the field. Verify that the text matches what was said and that nothing was typed twice.

  • Recover Web startup when one corrupt Session blocks it

    Isolate the one bad Session artifact so the Web client starts without touching healthy Sessions.

    View prompt
    Using the sandbaseai/deepseek-harness-handbook troubleshooting guide session-history-corruption-triage, help me with this startup error: <error text>. Identify the single Session artifact to isolate, and output the steps in order without changing the launcher or profile. Verify the Web client starts and that no healthy Session was altered.

  • Run a GPT-5 review of a branch diff

    Pipe a branch diff into Codex and get a single final answer back.

    View prompt
    In the Sateezg/codex-bridge plugin setup, pipe the diff of <branch> against main into codex-run with -C . and --timeout 1200, and report Codex's final answer. Verify that each finding names a real file and line in the repo before reporting it.

  • Let a coding agent drive the Mac from a shell command

    Call scripts/say.sh so an agent can open apps and use menus on the Mac.

    View prompt
    In the jev-use repo on this Mac, run `scripts/say.sh "<command>"` where <command> is the desktop action to perform, such as "Open Finder". Expect the Mac to perform the action and the app to report DONE, BLOCKED or WAIT. Verify by running the log command above and confirming the logged effect matches the requested action.

  • Set up a clone for a contribution with a coding agent

    Clone the repo, sync dependencies and follow AGENTS.md before changing code.

    View prompt
    Clone https://github.com/scaleapi/agentenv-framework, run `uv sync --extra dev`, then read AGENTS.md and CONTRIBUTING.md. Report the test tiers and pull request title format you found, and the change you plan for <target bug or feature>. Verify that the virtual environment activates before you edit any code.

  • Have an AI assistant diagnose a live SSH session

    Let a model read your terminal and run approved commands on a server, with control over each action.

    View prompt
    In the scarletkc/Hatoba app, open an SSH session to <host>, ask the AI assistant to find why <service> is failing, and keep approval on for every action. Verify that the assistant lists each command it ran and that you approved each one before execution.

  • Review architect and advisor consults in a session

    Check when the architect or advisor was consulted, how long each took, and what the inferred moments were.

    View prompt
    Install the scasella/claude-flightdeck plugin in Claude Code 2.1.287 or later, run a task that consults an architect or advisor, and open /flightdeck. Report the number of consults on the architect timeline and the duration of the last one. Verify that any moment labelled (inferred) is distinguished from measured consults.

  • Generate a 360 HDRI environment and apply it to the World

    Create a panorama or HDRI with Scenario and set it as the scene World background.

    View prompt
    Using the scenario-labs/blender-plugin Environment lane in Blender 5.0 or later, generate a 360 panorama for the prompt <prompt text> and apply it to the scene World. Report the CU estimate and the result name. Verify that the World background shows the new environment in the viewport.

  • Build a side-scroller sprite kit with parallax layers

    Generate side-view hero and enemy sprite strips, parallax layers, and platform tiles.

    View prompt
    Using the scenario-labs/skills repo, generate side-view sprite strips for <hero-description> with run, walk, attack, and hurt poses, plus three parallax layers for <level-theme>. Save everything to <output-folder>. Verify that the hero strip frames are the same size.

  • Give each AI agent its own identity and API key

    Register agents as identities with admin-issued API keys so their calls can be told apart.

    View prompt
    In the securetron-gh/aifw repo, start the gateway with `docker compose up -d` and register <agent-name> as its own identity with its own API key. Report the agent identity and key name, and verify that a test call made with that key shows up under that agent in the dashboard.

  • Serve Breeze TTS 2 speech through the local API

    Stand up the vLLM-Omni speech endpoint with a Breeze checkpoint and send it a test request.

    View prompt
    In the repo Sentinel3252/Native-Breeze-TTS-2-Support-for-vLLM-Omni, follow docs/getting-started.md and docs/api.md to start the speech endpoint with a checkpoint at <checkpoint path>. Send one short text prompt through examples/speech_client.py and report whether audio was returned and the server settings used, confirming tensor parallel size 1, eager mode, and prefix caching disabled.

  • Extend Window Seat with a new scene

    Have Claude Code add a scene to Window Seat and verify it with frame strips and the repo's gates.

    View prompt
    In the riso-windowseat repo, extend films/window-seat/ with <new scene description> using the riso-film skill and its gates. Expect an updated index.html and a revised FILM.md. Verify with the determinism hook and the frame strips that the existing timeline from 0 to 78 s still holds.

  • Check the local Codex CLI, Skills, and MCP setup before starting work

    See the detected Codex CLI version, Skills, and MCP server summaries in one view.

    View prompt
    Using the repository sevensir888/codex-command-center as a reference for what its Codex environment view shows, list the items I should verify on <machine name> before starting Codex work on <project name>. Output a checklist with one line per item. Verify that the Codex CLI version matches the version I expect.

  • Screen Office, EPUB and notebook files for tells

    Score the prose in .docx, .pptx, .xlsx, .epub and .ipynb files from the command line.

    View prompt
    Using the sloptrim repo at <repo path>, run `python scripts/detect.py <file>` on each of <file list> and report the score and the skipped areas for each. Verify that no output was redirected over an Office, EPUB or notebook file.

  • Let a coding agent batch-rewrite drafts through a local server

    Run the 12B model as a local llama-server and have an agent send each draft to it.

    View prompt
    Using the sgaofen/humanizer-local-model repo, start llama-server with the Q8_0 GGUF on port 8080 and rewrite every .txt file in <input-folder> through the /completion endpoint with the prompt format from prompt_format.json. Expected output: one rewritten .txt per input file in <output-folder>. Verify that a single test draft returns non-empty text from the .content field before running the whole folder.

  • Let a coding agent find, install, and edit Shaders

    Install the Shaders skill and MCP server so your agent can add and change effects in your project.

    View prompt
    Using the shader-effects-inc/shaders skill and MCP server, find a shader that matches <effect-description> and install it into <project-path>. Expected output: a new component file and a summary of the props set. Verify that the component is imported from the correct framework path.

  • Run the gateway as a native service on a Linux server

    Build and install Synapass without Docker, then run it under systemd.

    View prompt
    In the ShadowSafin/Synapass repo, build with make build, install with synapass native install, and start with synapass native up on <host>. Report the output of curl -sf http://127.0.0.1:8080/ready. Verify that the readiness check succeeds before reporting the service as running.

  • Point an existing Jev client at this server

    Switch a Jev client's base URL to a local RSI Jev server without rewriting code.

    View prompt
    Given an existing Jev client in <project-path>, point its base URL to localhost:8000 after running `rsi-jev serve v6.1-vl-4b --effort auto --port 8000` from the Shanghua-Gao/RSI-Jev repo. Run one existing client request and return the response. Verify that the client works with no other code changes.

  • Host a shared world session for friends

    Run the game as host so friends can join the same world by IP address or URL.

    View prompt
    On the host machine running Infinite Pokémon, start a Multiplayer host session and report the address a guest should enter. Verify that a second client can choose Join session and reach the host's starting map.

  • Share a finished avatar as one .mavatar file

    Export your saved avatar as a single file that another person can import into Studio.

    View prompt
    In the mesh-avatar-studio repository, export the project <project name> as a .mavatar file using the editor. Expect a downloaded archive under 128 MiB. Verify that it imports as a new folder under projects/ and plays in the preview.

  • Look up CVEs and known issues for a tech stack

    Query NVD and the tech correlation data to see which known issues match a product or version you run.

    View prompt
    Using the blitzstrike MCP server, call nvd_lookup for <CVE ID> and tech_correlation for <technology name>. Return the matching CVEs with their severity and the related product. Verify that each listed CVE is confirmed against the version you run before you act on it.

  • Fit a printed part to a real object you measured

    Scan or measure a real object, record its dimensions, and compare the design to a target mesh.

    View prompt
    Using the nurb repo (Shpigford/nurb), measure the scan file <target scan file path> with `nurb scan` and compare the part <target part name> with `nurb compare`. Expected output: a deviation report in both directions. Verify that every dimension the part needs is present in measurements.toml, since the README says asking for a missing one raises an error instead of guessing.

  • Build a custom Gideon app with the gideon.sdk package

    Start from the app template in examples and write an app against the Python SDK.

    View prompt
    In the Sidiora-Labs/centra-gideon-agent repository, read the app template under examples and write a new app that uses gideon.sdk to provide <capability>. Report the files you created and the app's requested permissions. Verify that the existing test suite passes with make test before you report success.

  • Run a supervised agent fleet across a spec hierarchy

    Start a detached supervisor that drives every wave, manager, and worker until work merges.

    View prompt
    In the Hyperfide repository, start the fleet with `hyperfide fleet up` and follow `hyperfide events --follow` for <N> minutes. Report which waves merged, which tasks were escalated, and whether any approval gate is waiting. Verify that completion is reported only for merged work.

  • Give an agent LayerX tools through MCP and A2A

    Install the MCP and A2A transports from the developer CLI so an agent can call LayerX tools.

    View prompt
    In the Sidiora-Labs/Paxeer-X-Network repo, locate the MCP server at services/agent/crates/layerx-mcp and the daemon at services/agent/crates/layerx-agentd. Run layerx install mcp and layerx install a2a, then report which transports were installed. Verify that layerx-agentd is reachable before reporting success.

  • Set up trending picks, weather and prices with your own TMDB key

    Build Free My TV with your city, your TMDB key and your currency so the picks and cards fit your home.

    View prompt
    In the free-my-tv repo, create config.properties by running ./build.sh, then set my city to <CITY>, tmdb_region to <COUNTRY_CODE> and currency to <CURRENCY>. Expected output: a rebuilt FreeMyTV.apk. Verify that config.properties stays out of git and that the build completes.

  • Run the scoring test suite before changing the rule

    Run the 35-test suite to confirm the scoring code still behaves as published.

    View prompt
    In the Simreal-MLBench repository, set up the virtual environment, install with `python -m pip install -e '.[test]'`, and run `python -m pytest -q`. Report the number of tests passed and any failures. Expected output: a pass count. Verify the count matches the 35 tests listed in the release status.

  • Run the built-in selftest in CI before publishing a release

    Check the Setup Gateway pure functions in CI without touching real config files.

    View prompt
    In the repo Sinholms/setup-gateway, run `node setup-gateway.mjs --selftest` and report the number of assertions and the exit code. Expect exit code 0 with no real config files changed. Verify that the exit code is 0 before approving any release step.

  • Validate a knowledge base before sharing it

    Run the structure, link, and TeX checks on a workspace before you hand it to others.

    View prompt
    In the my-kb workspace, run `python kb.py check --backend codex`. List each reported structure, link, archive folding, or TeX problem with its file path, fix only those files, and confirm the check passes again.

  • Hand off a job with a charter that defines done

    Write one charter with success checks, then let any agent deliver it.

    View prompt
    In the repo <repo-path>, write a charter with the work-orders skill from Sno Station Skills for the job described in <job-description>. Output one charter file with deliverables, out-of-bounds areas, decided items and a proof method for each success check. Verify that every success check names a real run that can pass or fail.

  • Add Cursor to a shared memory with Codex and Claude Code

    Connect Cursor so its chats use the same memory, skills and review flow as your other agents.

    View prompt
    In the sno-station repository, start a Cursor chat on a Linux or macOS machine and ask it to summarise the shared memory for <placeholder>. Expected output: a short summary that reflects work done in another agent. Verify that the answer mentions context not visible in the Cursor chat alone.

  • Compare public LinkedIn profiles and companies

    Search LinkedIn for people or companies and read selected profiles, companies, and posts with citations.

    View prompt
    Use the socai-io/jev-social repo to search LinkedIn for <segment> companies and people in my signed-in Chrome and produce a cited comparison. Expected output: a source-cited report.md. Verify that each claim links to a captured profile, company, or post and that login gates are marked as partial.

  • Add Claude Code hooks for session and tool activity

    Connect Claude Code through reviewed hooks so Agenttrail shows session trails and tool activity.

    View prompt
    In the repo <repo-path>, set up Agenttrail Claude Code hooks using the reviewed setup flow, then restart the Claude Code conversation. Report which provider settings files were changed. Verify that a short test task in Claude Code produces visible session activity in the Map or Kitchen view.

  • Review every tool call an AI coding agent made

    Read the local audit trail and watch live tool calls to see what an agent tried and what the guard decided.

    View prompt
    Using https://github.com/solongate/agent-security, run `solongate audit` after a session with <agent> in <project-path>. Expected output: a list of tool calls with their allow or deny decisions. Verify that ~/.solongate/local-logs/solongate-audit.jsonl contains one JSON object per decision, matching what the audit view shows.

  • Let an AI agent read your servers through local MCP

    Expose Maid Kit's servers, snippets, and skills to an MCP client on the same machine, with approval for actions.

    View prompt
    With the Solsynth/MaidKit app running from `flutter run`, connect an MCP client to its local MCP Server and ask it to list the servers in MaidKit. Expected output: a list of server names matching those on the Dashboard. Verify that a proposed action from the agent waits for approval before it runs on <server-name>.

  • Generate a daily A4 personal briefing PDF

    Build a monochrome A4 daily briefing from a validated JSON file and print it on a schedule.

    View prompt
    In the sosoj92/jarvis-assistant-vocal repo, follow docs/signal_matin.md to build a daily briefing from <JSON input file>. Expected output: an HTML preview and an A4 PDF file. Verify the PDF opens and contains the agenda and sourced news before reporting success.

  • Delegate a feature to an agent with checks at each stage

    Use the toolkit's workflow to move a request from design to verified, reviewed code.

    View prompt
    In the repo soumatheusgomes/vibe-coding-toolkit workflow, implement the feature <feature description> in this project at <project path>. Follow understand, design, plan, implement, verify, and review in order, and keep changes to the smallest complete change. Report the diff summary and the checks run. Verify that the checks passed and that pending work is listed.

  • Set up a daily briefing that runs on its own

    Create a routine that has an agent brief you every morning, even with the browser closed.

    View prompt
    Using the open-source repo SouravBeraAkaSpeed/xiryn, create a daily routine in Xiryn that briefs me on <topics> every morning at 8. Expected output: a briefing and a completion notice on the scheduled day. Verify that the routine still runs with the browser closed.

  • Migrate many files with a capped parallel run

    Run a broad migration in Grok Build with a fixed limit on parallel subagents.

    View prompt
    Using the Spielewoy/autoprompt-skill repo, run `autoprompt activate grok --target <absolute project path> -- --concurrency custom --max-subs 4 "<your migration goal>"`. Expected output: the migration applied across the target files and a summary of what changed. Verify that the project's test suite passes after the run.

  • Have an AI agent run the landmark pipeline in Blender

    Drive the landmark path and live Blender apply through the Blender MCP socket.

    View prompt
    In the squall01337/mixamo-llm-mocap repo, with Blender open and the Blender MCP add-on enabled, run the landmark path on <video path>, writing the beat sheet from analyze_landmarks.py numbers. Expected output: preview.mp4 and showcase.mp4 in the clip folder. Verify both files exist and that compare_reference.py reports the frame windows that still differ.

  • Export your library as a bibliography file

    Turn your Thesys library into BibTeX, RIS, EndNote, or CSV for your writing or reference manager.

    View prompt
    Use the Sreehari05055/thesys-core repo to open the library, select the papers on the topic <topic>, and export them as <BibTeX, RIS, EndNote, or CSV>. Output the file name and entry count. Verify that the file opens and contains one entry per selected paper.

  • Roll back the Claude Code hook changes safely

    Remove the wiring and keep your other Claude Code hooks, with a backup to restore from.

    View prompt
    In the clawd-conduit repo, run `bash uninstall.sh` and then parse ~/.claude/settings.json with python3 to confirm it is valid JSON. Report whether any non-repo hooks remain and which backup file was used if one was restored.

  • Try Starling Office in a browser to draft documents

    Open the Writer, Slides, and Sheets apps in a browser with no install.

    View prompt
    Open https://writer.starling.build/, https://slides.starling.build/, and https://sheets.starling.build/ in a browser and check that each one loads. Expected output: a short list stating which apps loaded and which did not. Verify each page loads before reporting that the app works.

  • Pair one agent with a reviewer that checks each turn

    Have one agent write changes while another approves them or returns findings, round by round.

    View prompt
    Using the Tellurion repo at https://github.com/steventsvik/Tellurion, start a review loop in <project-folder> with Codex as writer and Claude Code as reviewer, with a round limit of 3. Report the reviewer's answer for each round. Verify that no message reached an agent before you clicked Send.

  • Run MCP actions from a native Windows workspace

    Manage MCP connections, apps, actions and runs from the Qt desktop app.

    View prompt
    Using the Superpower repo at https://github.com/stloendays/Superpower, download the latest portable Windows package from GitHub Releases, connect it to the MCP server at <endpoint>, and run the action <action name> from the Actions view. Expected output: a completed entry in Runs with its result. Verify that the Runs entry shows the same tool name and status as the review step.

  • Embed Box in a Rust application as a library

    Call strands_box::run from your own Rust host process to start a sandboxed workload.

    View prompt
    Using the strands-agents/box repository, link the strands-box package in crates/box into a Rust host app and call strands_box::run with an absolute path to <box.toml>. Expected output: the function returns an exit code after the agent finishes. Verify that a second run call in the same process fails.

  • Check a form image for a filled-in field

    Ask a yes or no question about an image, such as whether a signature block is filled in.

    View prompt
    Using the strands-decider repo with the vision extra installed, run the ask command on <image path> with a noul question about <field>. Return the noul value. Verify the result on two known pages, one filled in and one blank, before trusting the scores.

  • Compress JSON event files smaller than zstd -3

    Use the Glyd CLI to shrink a large JSON file and restore it exactly.

    View prompt
    Using the repo surya-koritala/Glyd, install the glyd CLI and compress <input file> to <output file>.glyd with `glyd --max <input file> -o <output file>.glyd`. Restore it with `glyd -d <output file>.glyd -o <restored file>`, then report both file sizes and whether the restored file matches the original. Verify that the restored file is byte-identical to the input.

  • Track a new employer by copying its careers URL details

    Add a company to config.yaml using the board and slug taken from its careers URL, then scan it.

    View prompt
    In the jobradar repo, add <company name> with the correct board and slug to the companies list in config.yaml, then run ./run.sh scan and ./run.sh list. Report the board type and slug used and the number of openings found for that company. Verify that the company name appears in the list output.

  • Generate an authenticator code locally for your own account

    Compute a time-based one-time code on your machine using the totp_code tool.

    View prompt
    Using the sv-number/mcp-server totp_code tool, compute the current authenticator code for <account name> from its secret. Expected output: the current time-based code computed locally by RFC 6238. Verify that the secret is not echoed in the response or in any log before you use the code.

  • Find affordable date ideas across MCP clients

    Connect SyncSo to Cursor, Windsurf, VS Code or any MCP client and ask for priced, bookable plans.

    View prompt
    Using the SyncSo MCP server from SyncSo-Inc/syncso, find New York events for a couple three weeks from now that cost under <budget> per person. Return a shortlist with dates, prices and booking links. Verify that each price and booking link came from the search results.

  • Give coding agents a queue for the GPU instead of killing processes

    Install the Berth skill so Claude Code or Codex asks for the card rather than killing GPU jobs.

    View prompt
    On the machine with the Berth repo, run `berth skill install` and then `berth status`. Expected output: the skill is installed for the agent and the card's holder is listed. Verify that a GPU task started by the agent runs through `berth run` and does not kill other GPU processes.

  • Reuse verified research and review methods across agent roles

    Store research, review, test, and release rules in agent roles so later tasks reuse them.

    View prompt
    Read the README at <repo-path>/README.md, section 团队方法可以复用, and list which elements an agent role can be configured with. Report what the README says about human review, and do not add features it does not describe.

  • Use Codex CLI through the router's responses endpoint

    Point Codex CLI at the /v1/responses surface so it runs on free-tier models.

    View prompt
    In the freellmapi repo (tashfeenahmed/freellmapi), configure Codex CLI in <project-path> to use http://localhost:3001/v1 with the unified key from the Keys page. Expected output: Codex CLI completes a small task. Verify that the router logs a /v1/responses request.

  • Build a company plugin that calls internal APIs with member login

    Write a Host plugin that uses workdshEnterprise to call your company backend without handling tokens.

    View prompt
    Using the WorkDSH repo at techflag/workdsh, write a Host plugin named <plugin name> that injects workdshEnterprise and calls the business operation <operation> on the company backend. Expected output: a plugin entry that returns the member identity and the list response. Verify that the request reaches the POST endpoint under /api/extensions/ and that the backend rejects members without permission.

  • Point Claude Code at DeepSeek or OpenRouter models

    Use an Anthropic-compatible provider such as DeepSeek or OpenRouter with the Claude Code agent.

    View prompt
    In Mobile Harness on an ARM64 Android phone, configure the OpenRouter provider with my API key and ask Claude Code in the AI Workspace to explain the files in <project-name>. Expected output: a reply from the chosen model in the chat. Verify that the provider shown in settings matches the one used for the reply.

  • Remove noise and reverb from a voice recording

    Restore a noisy or reverberant speech clip to clearer audio with one instruction and no separate tools.

    View prompt
    In the Tencent-Hunyuan/AuK repo, run auk-infer on <noisy.wav> with an instruction asking for noise and reverberation removal, and save the output as <clean.wav>. Verify that <clean.wav> exists and has the same duration as <noisy.wav>.

  • Run an unattended team of agents that message each other

    Host several isolated agents in one process that call each other through the Teams peer inbox.

    View prompt
    In the TencentCloud/octop-harness repo, create three isolated agents with AgentManager and set ask_user_enabled=False and peer_invoke_mode to <mode>. Send the task <task> to agent <name> and verify it receives a reply from a peer.

  • Run the standard build workflow for a full game goal

    Give an agent one end-to-end game development goal using Vibe Game's standard build workflow.

    View prompt
    Using the VibeGame repo at https://github.com/tettethu/VibeGame, run the /vibegame-build workflow in my-game with the goal "<end-to-end game goal>". Expected output is a built game in my-game that matches the goal. Verify by running vibegame run --port auto and confirming the goal's main encounter is playable.

  • Run persistent memory on an OpenClaw gateway with chat feeds

    Install the Claude Mem plugin on an OpenClaw gateway and optionally send observation feeds to chat apps.

    View prompt
    On the OpenClaw gateway at <gateway host>, run the claude-mem OpenClaw installer from https://install.cmem.ai/openclaw.sh, then confirm the worker is running. Report the provider chosen and any chat feed configured. Verify that a test session creates an observation in memory.

  • Watch for leaked credentials with a Flare agent

    Hire an exposure analyst that checks your Flare feed for leaked credentials and sessions.

    View prompt
    Using the repo theNetworkChuck/paperclip-guide, install the Flare skill from skills/flare/ and run the first Flare sweep from prompts/tasks/ for <company domain>. Report the number of exposures by type. Verify that no credential or password appears in the output.

  • Pick the best frames and match exposure across a shoot

    Keep the sharpest frames and make the rest of the shoot look consistent in one pass.

    View prompt
    Using the repo thesnarkitecht/rembrandt, run Pick the best on the shoot at <folder-path> and then Make these consistent using <hero-frame-name> as the hero. Report how many frames were picked and rejected, and check that your own flags were kept.

  • Run the chat app on a local model with Ollama and no API key

    Point the app at a local Ollama model so answers run on your own machine.

    View prompt
    In the thesysdev/open-intelligent-ui repo, follow the Run with a local model (Ollama) section: pull qwen3.8:27b, set OLLAMA_CONTEXT_LENGTH to 32768, set MODEL_PROVIDER=ollama in .env and start npm run dev. Send one travel prompt and report whether the answer renders as UI or as broken output. Verify the context window is at least 32768 before testing.

  • Stream a LangChain agent's output as live UI

    Connect a LangChain or LangGraph agent to OpenUI through AG-UI for streamed UI responses.

    View prompt
    In the thesysdev/openui repo, wire the @openuidev/langchain transformer into the LangGraph agent at <target agent path> so its output streams as OpenUI Lang over AG-UI. Expected output is a streamed UI response in the client; verify by running one request that returns a table or form component.

  • Build a new System 1 agent for your own task

    Use the builder skill to probe a task and write a System 1 agent module.

    View prompt
    In the system1-agents checkout, use the builder skill to create a System 1 agent for <task>, ending in a frozen SPEC under s1a/agents/. Report the new module path, the probe results and the score from one run. Verify that the agent stops if the task needs deduction or arithmetic.

  • Lock the car from your phone after an alert

    After the car reports an open window or unlocked door, lock it from your phone or watch.

    View prompt
    Using the CarWatch repo at https://github.com/ThinkOffApp/CarWatch and the setup in docs/remote-access.md, send a lock request to the car from <phone-or-watch> and report the lock state read back afterwards. Verify that the reported state is locked and that the request was made from outside the home network.

  • Trace each request's cost and route, then replay it on another upstream

    See which upstream served a request, what it cost, and compare the answer with a replay on a different upstream.

    View prompt
    Using the repo ThinkWatchProject/ThinkWatch-Lite, send one prompt through the upstream <upstream A> and replay it on <upstream B>, then report both costs and whether each cost is marked as estimated. Expected output: a side-by-side comparison of the two answers and costs. Verify that requests without a price are counted separately, not as zero.

  • Check references, repeated numbers, and hidden PDF text

    Run three helper scripts that report candidates for references, numbers, and hidden text.

    View prompt
    In the absent-author repo, run tools/ref_verify.py on <refs.bib>, tools/number_ledger.py on <main.tex>, and tools/pdf_hidden_text.py on <paper.pdf>. List every candidate with its source location. Verify each candidate by reading the cited source yourself, since the tools report candidates, not verdicts.

  • Improve a harness with reliable rewards and reflection

    Use reward-based evaluation and GEPA reflection to evolve a harness from full execution traces.

    View prompt
    Using the JevHarness skill from https://github.com/TianyuCodings/JevHarness, plan an evaluation and reflection loop for <task> with a trusted reward, a training batch, and an Eval set. Expected output: a plan naming the selection split, the reflection inputs, and how accepted proposals are checked on Eval. Verify that the plan keeps Eval separate from the reflection inputs.

  • Rebuild a broken memory index from the Markdown files

    Delete the rebuildable index cache and regenerate it without losing any memory.

    View prompt
    Inside the agent-memory store at <store path>, run `rm -rf .index/ && mem rebuild`, then run a recall for <known topic>. Expected output: a non-empty L0 list. Verify that the count of Markdown memory files is the same before and after the rebuild.

  • Brief the content team on the inputs SEO needs

    Use the T checklist to tell writers and designers which titles, descriptions, and alt text SEO depends on.

    View prompt
    Using the tigerless-labs/seo-ops repo, read references/content/content-checklist.md and write a content brief for <content-type> that lists each SEO input, the reason it matters, and the C check it feeds. Verify that every input in the T set appears in the brief and that each one names at least one C check.

  • Skip one Google Calendar event with Undo

    Ask in chat to remove a single recurring meeting from your Google Calendar.

    View prompt
    In the TimeLovercc/mojito repo, remove only the occurrence of '<event-name>' on <date> from the connected Google Calendar. Expected output: confirmation that one occurrence was removed and the series is otherwise unchanged. Verify in Google Calendar that the other occurrences still exist.

  • Rerun NeoHorse-1 with the reported sampling settings

    Serve a NeoHorse-1 checkpoint with the exact SGLang settings listed for the technical report.

    View prompt
    In the TokenRhythm/NeoHorse repo, serve the NeoHorse-1-9B checkpoint at <model-directory> with SGLang v0.5.17 on port 30000 using the reported protocol settings in the Evaluation section. Send the benchmark prompt <benchmark-item> and return the answer and the settings used. Verify that the request sets temperature=1.0, top_p=0.95, and top_k=20 before recording any score.

  • Run a long task in the background with a review gate

    Start a long team task that keeps running in the Run Center, with a reviewer and up to two repair rounds.

    View prompt
    Using the dsh-agent-team-gui repo, start a background team run for <task-description> in <project-path> with a quality gate of 1 repair round. Report the Run Center status, final quality gate decision, and any Interrupted runs. Verify that the run's final state matches the reviewer's accepted output.

  • Build and test Talkify from source with xcodebuild

    Clone the repo, build the app headless, and run the test suite the way CI does.

    View prompt
    In the local clone of tornikegomareli/Talkify at <path>, run the test command from the README and report the number of passing and failing tests. Verify that the test command uses the platform=macOS destination before you report.

  • Deploy a shared hosted harness for a team

    Run TrueForge in hosted mode with Postgres and Redis so a team shares one agent setup.

    View prompt
    In the truefoundry/trueforge repo, deploy hosted mode using <deployment-method> (Docker Compose, Helm, or Railway) following the Quickstart, then connect one model and one MCP server. Report the deployment URL and confirm that a login is required. Verify that a shared agent runs successfully for a second user.

  • Run a real mail server that receives mail for your domain

    Install Sentio without Docker and run it as a systemd service on port 25.

    View prompt
    In the truespar/sentio repo, build with cargo build --release, run the migrate command against config/default.toml, and enable the sentio-smtp systemd service. Report the output of curl localhost:8080/health/ready. Verify that port 25 accepts a connection from an external test host for <your-domain>.

  • Audit what the agent did on a deal before you trust it

    Open the Agent tab on a deal to see each step, discarded leads and open questions.

    View prompt
    In the trycompai/crm CRM, open the Agent tab for the deal <deal-name>, list each step, each discarded lead with its reason, and each open question. Report those items in a short table. Verify that every schedule_recheck entry includes a stated reason.

  • Shorten test and lint output so an agent reads only failures

    Wrap npm test and lint commands with Reslop so agents get failures and a short summary, not passing noise.

    View prompt
    In the repository at <repo-path>, run `npm test` and read the reduced report that reslop saves in .log/. Report each failure with its file and the raw log path. Verify that passing results are absent from the report and that the raw file in .log/ exists.

  • Generate an interactive Cleanup Map from an audit

    Turn a confirmed audit into a desktop HTML map with linked findings and evidence drawers.

    View prompt
    Use $simplify-codebase to audit <repo path> and generate a Cleanup Map with Finding deep links after I confirm. Do not present reachable relationships as runtime impact. Expected output: a validated interactive HTML file alongside the text proof records. Verify that every node on the map matches a confirmed finding in the text report.

  • Upgrade an older memory install and keep your own edits

    Move a machine to a newer pack while receipt hashes protect edited files.

    View prompt
    In the new ai-memory-skillpack checkout, follow INSTALL.md and the migration/ procedure to upgrade the memory install on this machine. Expected output: a list of files replaced, files kept because of local edits, and the archive path of the old pack. Verify that no file with a receipt hash mismatch was overwritten.

  • Fail pull requests that repeat storyboard effects

    Set up the variety audit GitHub Action so every storyboard is checked on push and pull request.

    View prompt
    Use the saas-motion-kit repo's variety-audit.yml workflow in <team repo>. Push a storyboard change to a branch and open a pull request. Expected output: a passing or failing variety audit check. Verify that the check fails on a storyboard that repeats an effect, and passes once it is fixed.

  • Run typed extraction on your own GPU to keep data in-house

    Serve Qwen3.8-27B with SGLang and point Type LLM at it so documents never leave your server.

    View prompt
    Set up TypeLLM/TypeLLM against an SGLang server at <server_url> serving Qwen/Qwen3.8-27B. Run TypeLLMClient.generate() on <document_path> with the questions in <questions_file> and return response.result. Verify that the model returned values for every field and no value falls outside its enum.

  • Reproduce the sidecar vs direct video benchmark

    Run the repo's synthetic benchmark to check the token and accuracy numbers yourself.

    View prompt
    In the repo UditAkhourii/cdaf, run the benchmark steps `python benchmarks/bench.py make`, `run`, and `report` in order, and write the results to benchmarks/RESULTS.md. Verify that the report lists accuracy and mean prompt tokens for both the direct video condition and the CDAF sidecar condition.

  • Find where a feature lives in a large codebase or file

    Rank files by relevance to a question, or find the lines in a huge file that match it.

    View prompt
    Using the repo UditAkhourii/quicksilver, run qs rank with the question "<feature question>" against <target-directory> with --top 5. Return the ranked file paths and say which one most likely implements the feature. Verify that the output lists no more than five files.

  • Call UE Box tools from a script or CI job

    Use the Uebox command line to ask a question or call one engine tool from automation.

    View prompt
    Use the uebox command line from the ueboxai/uebox repo to ask the open project <project name> how many light actors the level has, and output the answer as JSON. Verify the job by confirming the command ran read-only and returned a numeric value.

  • Serve an agent-built site on a local subdomain

    Run the ingress so sites that agents build are reachable on ufo.localhost subdomains.

    View prompt
    In the ufo-core repo, run `uv run ufoctl ingress` and ask the agent to build <site description> in the workspace. Expected output: the site loads at a subdomain of http://ufo.localhost:8100. Verify the page loads in a browser before you report success.

  • Get a sourced research digest on a schedule

    A research agent reads papers, docs or competitors on a schedule and reports only when something matters.

    View prompt
    Using the Overtime repo at ukanwat/overtime, create a research agent that reads <list of sources> on a schedule. Expected output: one report with a source link for each item. Verify that every claim in the report links to a source the agent actually read.

  • Feed live calendar, email and chat into the vault

    Follow the live-data guide to let the agent read your calendar, email and chat.

    View prompt
    Using the live-data guide in the second-brain-os repo, connect the calendar, email and chat sources for the vault at ~/brain. Report which sources connected and list one item read from each. Verify that no credential is written into any markdown file in the vault.

  • Run agent tools inside a remote sandbox

    Send serialized operations from a proxy operations manager to a local manager inside a remote sandbox.

    View prompt
    Using the unreal-agent repo at <repo path>, set up a proxy operations manager that sends serialized operations to a local operations manager in <sandbox name>. Expected output: the result of a harmless Bash command run inside the sandbox, shown in the session. Verify that the command ran in the sandbox and not on the host.

  • Build Rune from source to test code changes

    Clone the repo, run Rune from source, and compile all executables to test your own changes.

    View prompt
    In the repo unstablebuild/rune, clone the source, run `make -j16`, and report whether the executables appear in ./bin. Verify by listing the ./bin folder and confirming the build exits without errors.

  • Schedule a recurring agent task and review its history

    Set up a task that runs on a schedule and check each run's history without starting it by hand.

    View prompt
    Using the UseAgent hosted app, create a recurring automation that asks the agent to <task description> on a weekly schedule. Expected output: a stored run history entry for each scheduled run with its output files. Verify that a manual run and the first scheduled run both produce the same kind of output.

  • Run audits on a schedule when no turn is active

    Schedule repeated audit or overnight runs that fire without an open conversation.

    View prompt
    In the repo at <repo-path>, use schedule_task to run <audit description> on a <cadence> schedule. Expected output: a scheduled entry and a result in the thread after the first run. Verify that a run happens with no open turn.

  • Rename subscriptions and models for a shared setup

    Give providers and models clearer display names in the picker without changing their IDs or routing.

    View prompt
    Using the dsh-plugin-subscriptions repo, set the display name of the <provider> subscription to <name> in DSH Settings. Expected output: the new name shown in the session model picker. Verify that the provider and model IDs are unchanged.

  • Keep a Claude Code session from filling its context

    Use a Jev-based compaction tool to drop stale tool results and keep the rest verbatim.

    View prompt
    Install the compaction tool from https://github.com/tamaratran/fast-jev-compaction into Claude Code and run it on the session for <task>. Expected output: a context size report that shows dropped stale tool results and kept verbatim entries. Verify that no recent tool result was removed.

  • Compare local models on your card before you commit

    Switch between installed models on a running server to see which speed and answers suit you.

    View prompt
    With the PolyStrata server running on localhost, send the same prompt <test prompt> to each installed model in turn, switching models between runs. Expected output: a table of model name, approximate tokens per second, and a short quality note for each. Verify that every model answered the same prompt and that the speeds were measured on this PC.

  • Cut dead air and keep existing captions in sync

    Find speech ranges, apply a cut list in one encode, and retime the transcript to match.

    View prompt
    In the veedstudio/open-edit repo, probe speech in <video path>, write an edl.json with the kept ranges, then run apply-edl and retime-transcript. Expect cut.mp4 and a retimed transcript under runs/cut. Verify that the retimed transcript timings fall inside the cut duration.

  • Have the factory fix red CI on its own draft PRs

    Let Foreman diagnose a failing check on a factory PR and push the fix to its own branch.

    View prompt
    On the repository <owner/repo>, find the factory draft PR on branch <factory-branch> with failing CI. Verify that Foreman pushes its fix to that factory/ branch only and that CI on the PR turns green after the push.

  • Build and send an email campaign after approving each step

    Have the email specialist turn copy into a Resend campaign and send it only after you approve.

    View prompt
    Using vercel-labs/marketing-team-eve-template, ask the lead agent to have the email specialist prepare a campaign for <segment> from <copy source>. Expected output: a Resend campaign link, with the send held for approval. Verify that the send does not run until an approve action is given.

  • Write and share a new agent skill

    Generate a skill template and edit its SKILL.md with instructions for your agent.

    View prompt
    Run npx skills init <skill name> from the vercel-labs/skills CLI, then fill in the generated SKILL.md with instructions for <task>. Report the path of the SKILL.md file and confirm the frontmatter follows the format in docs/creating-skills.md.

  • Build and run DSH Desktop from source

    Clone the repository, install dependencies, run the diagnostics, and start the Electron app locally.

    View prompt
    Clone the vibeinging/dsh-desktop repository into <target-dir>, run npm install and npm run doctor there, and report the doctor output and whether it passed. Verify first that the Node.js version is 24 or higher, as the README requires.

  • Self-host the full Vicoa stack with Docker

    Run the Vicoa backend, web app, and database on your own infrastructure using Docker.

    View prompt
    Using the vicoa-ai/vicoa repo, self-host the Vicoa stack on <server-address> by following SELF_HOSTING.md. Confirm that the Docker containers started with `docker compose -f docker-compose.selfhost.yml ps` and that the web app loads at the URL you set. Report the running services and the URL.

  • Check a built 3D scene by capturing its real frames

    Drive a built scene through named views and clicks, then review the saved PNGs and console log.

    View prompt
    Using the 3dviz-pro-max skill in <repo-path>, run the capture helper on the built scene at <scene-path> and save the named views as PNG frames with the console log. Report whether each claimed feature appears in the frames and list any mismatch.

  • Predict which rule handles one app and destination

    Enter one process, destination, port, and protocol to see the rule that would match it.

    View prompt
    In the Vincent-Xi08/IntentRoute-AI repo, run the Route Decision Simulator for the process <process name>, destination <domain or IP>, port <port>, and protocol <TCP or UDP>. Expected output: a proven match, a proven fallback, or an indeterminate result with a trace. Verify that the simulator performed no DNS lookup, proxy probe, or configuration change.

  • Narrate an explainer in another language

    Render the same script with a local voice in Spanish, Japanese or another supported language.

    View prompt
    In the explainroo repo at <repo folder>, write a script in <language> and render an explainer video for <topic>. Expected output: one MP4 narrated in that language. Verify that the speech check reports no wrong words before you report the file path.

  • Render explainer videos on a Raspberry Pi 5

    Run the full pipeline on ARM Linux with system Chromium and a local or cloud voice engine.

    View prompt
    On this Raspberry Pi 5 with the anything2explainer repo cloned, set REMOTION_BROWSER_EXECUTABLE to the system Chromium and generate voiceover with TTS_ENGINE=piper, then render a short test video. Verify that the render finishes and produces an MP4 that plays with audio.

  • Rewrite one agent response on demand

    Invoke the Nopus simplify skill to request a clearer rewrite when automatic checks did not trigger.

    View prompt
    Using the nopus repo at Vistyy/nopus, run `/nopus:nopus-simplify` in Claude Code or `$nopus-simplify` in Codex in <project directory> right after the response you want rewritten. Expected output: a revised version of that response. Verify that technical terms, commands, identifiers, and conditions appear unchanged in the revision.

  • Audit a codebase with bundled security workflows

    Run Codex Security workflows on your own code and get evidence-backed reports.

    View prompt
    Using the VelaTerm repo at https://github.com/vlinx-io/VelaTerm, read docs/manuals/code-audits_20260908.md and run a code audit on the project at <project-path> that I own. Expected output: a Markdown or JSON report with source evidence and coverage limits. Verify that every finding links to a file and line in the source before you trust it.

  • Deploy an app to Google Cloud Run from chat

    Use the Cloud Run MCP server so an AI assistant can deploy your app to Google Cloud Run.

    View prompt
    Using the Cloud Run MCP server from VoltAgent/official-mcp-servers, deploy the app in <project-folder> to a Cloud Run service named <service-name>. Return the service URL. Verify the URL responds with HTTP 200 before reporting success.

  • Install the skill for Claude Code and Codex

    Clone the repo and run the install script to add the skill to both agents.

    View prompt
    Using the forward-implementation-first repository, install the skill for Claude Code and Codex on this machine. Report which skill directories now contain SKILL.md. Verify that both ~/.claude/skills/forward-implementation-first/ and ~/.codex/skills/forward-implementation-first/ exist after the install.

  • Trace why the chat bar picked a tool

    Use the inspector to read every classifier answer and probability behind a reply.

    View prompt
    In the jev-chat repo, run pnpm dev, send the message <test-message> to the chat at http://localhost:5173, and open the inspector for the reply. Report the tool choice probabilities and the policy action. Verify that the inspector shows the original message and the answer to each question.

  • Keep the HERO block active on overnight agent runs

    Put the block in an always-loaded file so long unattended runs keep the scope limits.

    View prompt
    Check that the HERO SCOPE LIMITS block is in the always-loaded config for this project. Then run <long task> and, at each checkpoint, list any hashing, extra review or scaffolding step and state which rule it falls under.

  • Build a typed triage gate for a bounded workflow

    Use Choice, Score and Noul answers to route items inside an existing pipeline.

    View prompt
    Using the awesome-jev-live README, design a triage gate for <your workflow> with one Choice question, one Score question and one Noul question. Output the gate code using the official SDK and verify that every branch is reachable on a sample of 20 cases.

  • Run research chats with memory and live web search

    Enable web search, page reading, and long-term memory so answers use today's web and past context.

    View prompt
    In the whirlchat/whirl repo, open docs/configuration.md and list the exact environment variable names for Exa and Supermemory. Output them as a table with the feature each one enables. Verify each name against the file before reporting.

  • Quantize a trained checkpoint to NVFP4

    Convert a saved checkpoint to a low-precision NVFP4 format with one Halo run command.

    View prompt
    In the whitecircle/halo repo, run `halo run quantize-to-lowp` with --input_dir <checkpoint_dir> and --output_dir <quantized_dir> and --format nvfp4 inside the Halo image. Expected output: a quantized checkpoint in the output directory. Verify that the input and output paths are different directories before running.

  • Build DSHCode desktop installers for macOS and Windows

    Run the desktop build command to produce installer artifacts, or use the Desktop workflow for the full matrix.

    View prompt
    In a clone of https://github.com/whitelonng/dshcode, run pnpm install and pnpm run desktop:dist, then list the files in .artifacts/desktop/release/. Report each file name and confirm that a checksum file is present or explain why it is not.

  • Rewrite short requests into detailed image prompts

    Use the official PE-T2I rewriter to expand a brief idea and get an aspect ratio.

    View prompt
    Using wildminder/awesome-qwen-image, load the Qwen/Qwen-Image-2.1-PE-T2I rewriter with AutoModelForCausalLM and AutoTokenizer, rewrite the request <request> using its system_prompt.txt, and return the English prompt and wh_ratio as JSON. Verify that you split the output on the think-tag before parsing JSON.

  • Batch-render sprites with Aseprite in headless mode

    Run Aseprite without a window so an agent can build a batch of assets in CI.

    View prompt
    Using the aseprite-ai-artist server from with-pebbly/aseprite-ai-artist in headless mode, draw the assets listed in <asset list file> and save each one to <output folder>. Expected output: one saved .aseprite file per listed asset and no changes to any file your editor has open. Verify that each file is saved and that the agent asked before switching modes if the window was not attached.

  • Check Codex and Claude quota windows before a busy day

    Read quota and window capacity estimates for each OAuth credential in one console.

    View prompt
    In the Oh My CPA console at http://127.0.0.1:8080/omc/, list each Codex and Claude OAuth credential with its estimated window capacity. Report the credentials that have less than half their window left. Verify each figure against the quota reading shown for that credential before you finish.

  • Bring Claude Code, Cursor or Codex setup and chat history into DSH

    Translate another AI coding agent's MCP servers, skills, instructions and conversations into a DSH import.

    View prompt
    Use the DSH Config Manager plugin to import the <source-agent> configuration and chat history on <machine> into DeepSeek Harness. Stop at the preview step, list the MCP servers, skills and conversations that would be imported, and state which secret key names need re-entry.

  • Score agent reproduction runs with the ReproBench adapter

    Turn each agent's reproduction task into a result file and a summary with the ReproBench commands.

    View prompt
    Using the VeriRepro repo (XiantingWu/VeriRepro), run `verirepro-reprobench task.json --output result.json` for the task file <task-file>, then run `verirepro-reprobench-summary results/*.json --output summary.json`. Expected output is a per-task result and a combined summary. Verify that the task file had no local, file, or insecure HTTP paper sources and that operator interventions are recorded.

  • Route existing MCP servers through one ChatGPT connection

    Add your MCP servers behind the single OpenChatX connection and sign in where required.

    View prompt
    Using the openchatx-mcp repo, add the MCP server at <server-url> through OpenChatX, complete any OAuth prompt, and call one of its tools. Report the server status shown in the Dashboard and the tool result. Verify that the status is not an authentication-required state.

  • Measure agreement between two judges on the same replies

    Compute Cohen's kappa between two action judges to see whether their verdicts agree.

    View prompt
    In the keystone-bench repo, run keystone compare-judges on two records.jsonl files that classify the same replies with different judges. Report the Cohen's kappa and name the judge pair used.

  • Run Baize on a local Ollama model so data never leaves your machine

    Use a local Ollama model as the backend for coding or analysis on sensitive material at zero API cost.

    View prompt
    Using the Baize CLI from the Xu123-Bob/Baize repo with active_provider set to ollama, ask it to summarize the files in <project-path>. Expected output: a summary generated by the local qwen2.5:7b model. Verify that Ollama is serving on localhost:11434 before the decree runs.

  • Run the Voice Mem voice demo in a browser

    Start the local web demo and talk to a voice agent that remembers what you said.

    View prompt
    In the VoiceMem repo at <repo path>, start python web/run.py and open http://localhost:8787. Ask the user to state a fact, then to ask about it. Expected output is a reply that uses the stated fact. Verify the log file in results/logs was written.

  • Scrape server metrics from a local model host

    Expose Kyojin's Prometheus metrics endpoint so a monitoring stack can track a local model server.

    View prompt
    In the Yamz-Labs/kyojin repo, start the Qwen server on port 8000 and confirm the Prometheus /metrics endpoint responds on <target host>. Expected output: a plain text metrics page from the server. Verify that the response contains metric lines before adding it as a scrape target.

  • Run tests, open PRs, and watch CI in an existing repo

    Have the agent work inside a repository to run tests, open pull requests, and check CI results.

    View prompt
    Using the repository yc-software/qm, deploy a QM instance and connect the repository <repository URL> to its sandbox. Have the agent run the tests, open a pull request for <branch name>, and report the CI result. Verify that the pull request exists and that the CI run has a status before reporting success.

  • Check verification, scope, and decisions before committing

    Run the workflow mods on a local checkout to review agent changes against scope and verification.

    View prompt
    In the repo YeonwooSung/my-claude-code-mods checkout, load verify-board and scope-guard with --plugin-dir and run /verify and /scope on the current changes for <task description>. Report each verification result as PASS, FAIL, STALE, or UNKNOWN and list any file outside the allowed paths. Verify that each reported file path exists in git status before you finish.

  • Call the open API to generate images or videos from a script

    Use the /api/v1 endpoints with a Bearer token or X-Api-Key header to run generation from your own code.

    View prompt
    Using the PRINTFILM API at http://localhost:8000/api/v1 and the route listed at http://localhost:8000/docs, submit one image generation request with the prompt <prompt> using the credential in <env var>. Return the task ID and the final result, and verify the response status is successful.

  • Submit a missing Jev project to the list

    Check a project against the inclusion rules and open a pull request with a one-sentence summary.

    View prompt
    Using the inclusion criteria in yibie/awesome-jev, assess <project repo URL> against the four rules and draft a one-sentence summary for it. Expected output: a pass or fail for each rule with a quoted line from the project as evidence, plus a summary under 140 characters. Verify that the summary describes the scenario, method, and value in one sentence.

  • Locate a target object in an image with boxes

    Get normalized bounding boxes for a named target in an image using the Box question type.

    View prompt
    Using the LLM2Jev repo, send the image <image-path> and a Box question for <target-description> to the running service. Return the normalized bounding box as JSON. Verify that coordinates fall between 0 and 1 before reporting.

  • Run a multi-step task through the graded protocol

    Use the graded plugin to split a big task into brainstorm, plan, check-ins, and final review.

    View prompt
    Using the repository yjh051108/dsh-routing-suite, install the graded plugin from graded/dsh-graded-mode-3.2.0.tgz and run the task <task-description> through the graded stages in order. Report the stage reached and the final review result. Verify that each stage produced its output before the next one began.

  • Create a character turnaround sheet for one design

    Adapt a character design prompt that asks for several views of one character in a single image.

    View prompt
    In the awesome-gpt-image-2-5-prompts repo, open prompts/gpt-image-2-5-character-design-prompts.md, pick a turnaround sheet prompt, and replace its character description with <character description>. Return the adapted prompt. Verify that it still asks for several views of one character in a single image.

  • Check a paper in ICLR, NeurIPS, or ICML wrappers

    Render the public conference-template demos to test formulas, citations, figures, and tables.

    View prompt
    Read the PairTeX README in this repo and render the demo/iclr project with pairtex_render.py using the build command shown there. Report the render output path and the URL from pairtex.py, and list which of formulas, citations, figures, and tables rendered without errors.

  • Build a new agent harness and score it

    Use the builder image and your own model key to generate a harness, then score it.

    View prompt
    Use the repo YuyaoGe/doc2harness to build a new harness with the builder tag <builder-tag> and output to <output-dir>, using the local LiteLLM gateway at <gateway-url>. Run the dry-run first, then the real build, and report the output path. Verify the dry-run printed the full plan before starting the real build.

  • Build a hook matrix from 18 hook tactics

    Turn one offer into a hook matrix and a diagnostic funnel for testing openings.

    View prompt
    Using the marketing-os skill in the Yuzzyuk/marketing-os repo, run the hooks module on <product or offer> and return the 18-tactic hook matrix and the diagnostic funnel. Verify that no hook claims proof that is absent from brand-context.md.

  • Retrain a DMAD student from the released training code

    Use the train folder and the published Wan2.1 training data to start a DMAD training run.

    View prompt
    In the Yzmblog/DMAD repo, read train/wan/README.md, download the DMAD-Wan-data dataset to data/wan, and start the training command from that README. Expected output: training logs for the Wan2.1 DMAD student. Verify that the dataset folder contains the 42,158 teacher samples the README lists before starting training.

  • Build a UI plugin from the Excalidraw example

    Follow the UI Plugin guide to start a plugin from the Excalidraw canvas example.

    View prompt
    In the zai-org/ZCode repo, read UI_PLUGIN.md and build a plugin named <plugin-name> following the Excalidraw example. Report the files created and confirm that the plugin page loads at http://localhost:5173 under `pnpm dev:web`.

  • Review AD certificate template exposure from exports

    Audit certificate templates, CA policy, and enrollment controls from supplied directory exports.

    View prompt
    Using the adcs-exposure-audit skill from the zero-lab-ai/skills repo, audit the certificate template and CA policy exports for <domain-name> that I provide. Return each control with an exposure rating and the export line it cites. Verify that every rating cites a line from the exports I supplied.

  • Automate CTF challenge steps with AI agents

    Use the CTF and recon agents with the LLM assistant to suggest commands and analyze terminal output during a challenge.

    View prompt
    Using the AI Security Tool repo at https://github.com/ZeroDayEvil/ai-security-tool, start the CTFWorkflowManager agent on the challenge at <challenge-address> and have it propose the next three commands without running them. Expected output: a list of three commands with a one-line reason for each. Verify that no command ran before a human approved it.

  • Compare two builds of a binary by function changes

    Diff two versions of a program function by function and read the changes like a code review.

    View prompt
    Using the Zfinix/eleven app, diff the builds at <path-to-old-build> and <path-to-new-build>, then ask the agent to list the five most important changed functions with a one-line reason each. Verify that each function name exists in both builds.

  • Draft an accept-or-reject rule for harness updates

    Write a checklist that accepts a harness change only when it beats the current state on held-out evidence.

    View prompt
    Using the zgcagi/Harness-RSI repo at https://github.com/zgcagi/Harness-RSI, read the Definition and Evaluation sections and write a five-item checklist that accepts a harness update only when it is established through evaluation for <my agent project>. Output the checklist as numbered lines, each with the README section it comes from. Verify that every item names an evaluator outside the candidate's editable surface.

  • Fill missing metadata for custom DSH model endpoints

    Auto-complete context, output, and modality fields for custom models from a models.dev index.

    View prompt
    Read the README of the repository at <plugin repo URL> (dsh-model-meta-autofill) and list which metadata fields it fills and how it refreshes its index. Expected output: a field list and refresh steps for a DSH setup at <target path>. Verify that the README names the bundled models.dev index before you say the index is refreshable.

  • Build the Linux desktop packages yourself from source

    Clone the fork, install dependencies, and produce x64 or arm64 packages locally.

    View prompt
    For the repo Zhou-Yujing114514/deepseek-harness-linux, clone it into <target-folder>, run `pnpm install`, and build with `pnpm --dir apps/desktop run package:linux:x64`. Report which package files were created under the build output and their names. Verify that the build exits with status 0 and that the files include the .AppImage, .deb, and .tar.gz types.

  • Host a private background removal API with Docker

    Run the Axum REST API on your own server, then create API keys for your apps.

    View prompt
    Clone github.com/zidniryi/unbagrnd, set UNBAGRND_ADMIN_KEY in .env, and start the stack with docker compose up --build. Expected output: a health response of {"status":"ok"} from http://localhost:8080/health. Verify the response and then use a generated key to call POST /v1/remove-background with an image from <image path>.

  • Diagnose a crash, ANR, or memory spike on a device

    Pull logs, process stacks, and a memory summary for one app to find the cause of a failure.

    View prompt
    Using the dsh-android plugin, call android_processes with filter <app name>, then android_backtrace with bundle_id <package name>, and android_meminfo with bundle_id <package name>. Expected output: the stack or crash-buffer result with the engine named, plus the memory summary. Verify the backtrace result states which engine answered before drawing a conclusion.

  • Drive a real iPhone over USB from the conversation

    Start WebDriverAgent on a connected iPhone and use the same tools and live panel as the simulator.

    View prompt
    Using the dsh-ios plugin in the ZSeven-W/dsh-ios repo, call ios_real_start_wda with the physical-device udid <udid>, then ios_sim_screenshot for that udid. Report the control and MJPEG ports and the screenshot path. Verify that WebDriverAgent reports ready before you take any tap action on the phone.

  • Adapt the Evo VLM evolution loop to a new VLM task

    Reuse the typed mutation catalog, evaluation protocols, and Pareto selection for a different vision-language task.

    View prompt
    Clone https://github.com/zzzz7788990213-ops/EvoVLM and read the evolution/ and evaluation/ folders in research/evolving-vlm-inference-main. Propose a plan to swap in <path to your task manifest> while keeping the typed mutation catalog and Pareto selection. Verify that every proposed mutation is listed in the existing catalog and does not add new code generation.

  • Generate an offline dashboard of your pipeline

    Turn your tracker and application archives into a self-contained HTML report you can open offline.

    View prompt
    In the ai-job-search repo, run /html-report. Expect a self-contained HTML dashboard built from job_search_tracker.csv and the application archives. Verify that the stat card totals match the row count in job_search_tracker.csv.

  • Stop an agent from marking unfinished tasks as done

    Use dsh-todo-guard to keep todos across restarts and verify each completion against evidence.

    View prompt
    Using the repo 0xsline/awesome-deepseek-harness, install dsh-todo-guard from github:a903067276-rgb/dsh-todo-guard into DSH. Run a short task with <todo list> and report which items show verified, blocked, or unverified. Verify that the todo list is still shown after restarting DSH.

  • Manage Fish voices for a remote agent in Desktop

    Install the plugin from Git into a remote Hermes agent and use the Voices page in Desktop.

    View prompt
    Using the repo 100yenadmin/fish-audio-hermes, install the plugin into the connected agent <agent name> through Hermes Desktop and restart its gateway. Expected output: a Voices row for that agent in Desktop. Verify that the agent's status shows a Fish Audio key and a selected voice.

  • Reject an unfeasible travel itinerary before presenting it

    Run the offline planning demo to see time, budget, and route constraints reject a bad plan.

    View prompt
    Using the ResiMind repo at <repo path>, run the open-planning demo and report which candidate itineraries are rejected and why. Expected output: rejected plans with the failed time, budget, or route constraint named. Verify that accepted plans satisfy every supplied hard constraint.

  • Run the local web dev server behind an HTTP proxy

    Route model and API calls through a proxy while developing Pi Agent from source.

    View prompt
    Using the abcwyc/pi-agent-desktop README, prepare the commands to start the dev server behind the HTTP proxy at <proxy-url>. Expected output: the exact environment variables and the npm command to run. Verify that NO_PROXY keeps localhost and 127.0.0.1 off the proxy.

  • Build and test ACRYL from source for a contribution

    Clone the repo, sync upstream, and run the verify and check gates before handing off a change.

    View prompt
    Using the acryl repo at github.com/acryldev/acryl, clone it into <target-dir>, sync upstream, install with the frozen lockfile, and run the verify script. Report the pass or fail result of the typecheck and tests, and verify that `corepack pnpm run check` completes before you finish.

  • Drive a coding agent on a remote dev box from your laptop

    Run the conversation on a remote machine with codeaf chat --host and keep the work going.

    View prompt
    Use the CodeAF repo at Agent-Field/CodeAF. Install it on a dev box named <host> and on a laptop, then run `codeaf chat --host <host>` from the laptop. Expected output: the live conversation of the dev box in the local terminal. Verify that a task started on the dev box keeps running after the laptop disconnects and that its result is visible on reconnect.

  • Stress-test your GTM claims before you ship

    Have the agent review your landing page or launch copy as a skeptic.

    View prompt
    Run review-the-work and value-prop-that-converts in the gtm-cofounder skills on this draft for <product name>. Expected output: a list of flagged claims and a revised value prop. Verify that every remaining claim can be backed by something the user can check.

  • Score a film with original music and check it before release

    Compose a score for your film and run the music check to catch loudness, masking and copied-sounding material.

    View prompt
    Using the anidoodle repo, compose an original score in the <music style> style for <film name> and run node tools/music.mjs check on it. Return the audio file and the check report, and confirm it passes key, loudness, masking, balance and novelty.

  • Install OpenCode into a chosen directory on a shared machine

    Use the install script with OPENCODE_INSTALL_DIR to place the binary where you want it.

    View prompt
    Install OpenCode from the anomalyco/opencode install script into <install-directory> by setting OPENCODE_INSTALL_DIR. Expected output: an opencode binary in that directory. Verify with the install directory check you choose, and confirm that no earlier install takes precedence on the PATH.

  • Control Blender from an external MCP client

    Connect an MCP client to Blender's authenticated local endpoint and run scene tools from it.

    View prompt
    Connect to the authenticated local Streamable HTTP MCP endpoint of the mcp-for-blender-pro add-on, following docs/CONNECTIONS.md. Call get_scene_info on <target .blend file> and return the scene summary. Verify the call succeeds with Blender open and that no object changed.

  • Drive Blender from OpenCode through the built-in MCP server

    Connect an external MCP client to Blender's authenticated endpoint and run scene tools from it.

    View prompt
    Connect OpenCode to the mcp-for-blender-pro MCP server running inside Blender, then call get_scene_info and list_objects for <scene name>. Expected output: the scene summary and object list returned by the tools. Verify that the object count matches what is shown in Blender's outliner.

  • Review an app's animations and produce a fix plan

    Have an agent audit motion in your app and list what to delete, move off the JS thread, or add velocity to.

    View prompt
    Using the appllama/appllama-skills repo, review the animations in <project folder> against the motion bar in appllama-app-design-skill. Output a fix plan that lists what to delete, what runs on the wrong thread, and what lacks finger velocity, and verify the plan's changes in the simulator recording.

  • Add a new model recipe to the repo

    Create a model folder with a README, kernel script and notebook following the repo's layout.

    View prompt
    In the ARahim3/kaggle-tpu-lab repo, add a new top-level folder for <model> with README.md, kernel/ and notebook/ following the Adding a model section and the existing folders. Expected output: a new folder whose notebook runs on Kaggle TPU and serves the model. Verify the config block matches between the launcher and the notebook.

  • Check agent subscription quota from the computer

    List the quota each agent on the computer can report, and turn on Claude collection.

    View prompt
    In the arronKler/pairfob repo, run `pairfob quota list` on this computer and report which subscription quotas it lists and any reason given for missing ones. Verify the command output matches the list of agents named in the README's quota feature.

  • Measure real tool time with live Docker tool calls

    Run the recorded shell commands in Docker containers so tool time is measured, not skipped.

    View prompt
    Using the agentperf-local repo from ArtificialAnalysis, build the default containers, then run `agentperf-local run` with --tool-mode live against <base-url> with model <model-name>, writing to results/<name>. Expect tools.json and summary.json in that directory. Verify that --live-network none was passed unless network access was explicitly needed.

  • Draw a leave plan or a pay breakdown as a clear diagram

    Ask your agent to chart a year of leave or where your pay goes, and share the result as one file.

    View prompt
    Use the SeeCode skill from the Aryanutkarsh/SeeCode repo to draw <a timeline of my leave or a Sankey of my pay> from <the plain-words description or CSV path>. Expected output: one diagram file. Verify that the totals in the diagram match the source numbers.

  • Install the distilled Hermes skills from the WikiSkill tap

    Add the WikiSkill skills tap to Hermes and install the patterns from live runs.

    View prompt
    Using the ashutoshsinghpr7/wikiskill repo as a Hermes skills tap, add the tap and install the skills search-miss-binary and script-exec-blocked. Report which skills were installed. Verify that each skill name appears in the Hermes skill list after the install.

  • Make a 25-second clip to share without showing code

    Record a short shareable clip of the call with commands, file names and screenshots hidden.

    View prompt
    In the repo Atoll92/agent-standup, open the live call, enable Hide code & file names in videos, and record a Clip to share. Report the saved file name and length. Verify by playing the clip that code, file names and pictures are masked and that spoken lines contain no secrets before posting.

  • Track AI tool drift across a fleet of machines

    Write per-machine JSON on a schedule and let --diff report drift for each machine.

    View prompt
    For each machine in <machine list>, run `npx geiger-scan --json <machine name>.json` and compare it with that machine's saved baseline using `npx geiger-scan --diff <baseline file>`. Return a table of machines with new executing or secret-holding findings, and verify that each JSON file has schemaVersion 1.

  • Perform a Strudel track and keep the WAV

    Bring voices in and out of a live Strudel track and save the best take.

    View prompt
    Using the Strudel harness in the openharness repo, write a four-bar beat at <tempo-bpm> BPM, add and remove two voices, and export the result as a WAV. Verify that the WAV file and the Strudel source are both saved in the workspace.

  • Switch the BoardUI app to Arabic or Hebrew layout

    Configure DirectionProvider and the document locale for a right-to-left interface.

    View prompt
    In the repo BoardUI/boardui, follow the RTL setup in the README for my project at <project-path> with locale <locale>. Expected output: the root layout wrapped in DirectionProvider and the document set to the right language. Verify that keyboard navigation and the date picker still work in the target locale.

  • Add paid video providers to expand generation options

    Add API keys to .env so the agent can use hosted image and video models for higher-end scenes.

    View prompt
    In the OpenMontage repo at <repo-path>, add the provider key for <provider> to .env, then list the provider menu with the registry. Confirm that the provider appears and report the cost per clip before generating anything.

  • Get reliable JSON and tool calls from a model in a backend service

    Make a model return valid structured output and handle tool-call errors in a service.

    View prompt
    Using the repo calmrocks/ai-engineer-notebooks, work through 01-model-apis/01-structured-output.ipynb and 01-model-apis/02-tool-calling.ipynb for <placeholder service task>. Expected output: a parser that returns valid objects for every test input and a log of tool-call errors handled. Verify that malformed model output is caught and retried rather than passed on.

  • Script repeat experiments with the Python SDK

    Run saved experiments from code and collect results as jobs and artifacts.

    View prompt
    In the canivel/dynolab repo, read docs/sdk-guide.md and write a Python script that submits an activation job for the model <model-name>. Expected output: a job result and its saved artifacts. Verify the artifact paths and that the job finished without error.

  • Ask JEV questions about objects from a live RGB-D camera

    Feed RGB and depth frames into a loop and ask JEV about detected objects with 3D positions.

    View prompt
    In the JEV_sees repo at <repo path>, write a camera loop that calls observe(rgb, depth, intrinsics=...) on each frame from <camera source> and then ask(...) with the question What is this object? Expect printed JEV answers per object; verify that objects include 3D positions or distances when intrinsics are supplied.

  • Open your Zotero library items as folded text

    Connect TextFold to the Zotero 7 app and read any library item in five levels.

    View prompt
    Using the TextFold repo at github.com/chenxiachan/textfold, enable Zotero 7 communication under Settings › Advanced, then open the Zotero library in TextFold. Expected output: your Zotero collections listed, and the chosen item shown at its folded levels. Verify that the item's title and authors match what is in Zotero, and that nothing in the Zotero library has changed.

  • Move profiles between machines and export cookies

    Export a profile as a ZIP and its cookies as cookies.txt for tools like yt-dlp or curl.

    View prompt
    Using the repo chienbm98/foxprofile, export the profile <profile-name> as a ZIP and its cookies as Netscape cookies.txt. Return the file paths and the number of cookies exported. Verify that the profile's browser was stopped before the export.

  • Run an actor inside a plain Bun process

    Start an actor from the Bun example without deploying to a Worker host.

    View prompt
    In the repo clavia-labs/tardigrade, read packages/examples/bun.ts and packages/examples/services.ts, set the model credentials for <model-provider> in services, then run `bun packages/examples/bun.ts`. Expected output: the actor starts in the Bun process. Verify that the services file provides the same services the actor's infer atom needs.

  • Rerank retrieved documents with Jev Noul scores

    Send candidate documents as Noul questions in one request and sort by the returned scores.

    View prompt
    Using the Jev reranker adapter in the milvus-model repository at github.com/milvus-io/milvus-model, rerank the candidate documents for <query> from <candidate set>. Output the sorted documents with original indices and scores. Verify that the top result matches a hand-judged best match for three queries.

  • Import the bundled role agents into Agent Studio

    Pack the five role agents as ZIP files and import them into Agent Studio.

    View prompt
    Using the Grasp repo (cocofhu/grasp), run ./agents/pack.sh ClarifyAgent and confirm the ZIP file is created in agents/dist/. Report the file name and the acpBackend value shown after import in Agent Studio.

  • Record a Codex CLI run that cannot be redirected

    Use opt-in TLS interception to capture a Codex CLI session that talks to its own backend.

    View prompt
    Use the OrcaReplay repo (Continuum-AI-Corp/OrcaReplay) to record a Codex CLI session with TLS interception enabled, following the README section on when the harness will not be redirected. Report whether `orca show last` lists model turns from the session. Verify that hosts not on the intercept list are listed in the trace as tunnelled.

  • Run coding agents on an SSH host you control

    Start agent sessions on a remote machine you own, without tmux, sudo, or a hosted relay.

    View prompt
    Using the diri repo at github.com/cristicretu/diri, start an agent session on the SSH host <ssh-host>, then close and reopen Diri. Output the session status before and after the restart, and verify the session still runs.

  • Find notes filed in the wrong folder and check wiki health

    Use the audit and health commands to review where CROW would move notes and which folders keep growing.

    View prompt
    In the llm-wiki-v2 wiki at <wiki path>, run llmwiki2 audit and llmwiki2 health and summarize the proposed moves and flagged folders. Expected output: a table of notes with proposed folders and a list of folders to review. Verify that no note moves until a human runs the apply step.

  • Share a mini-sglang build log with the community

    Write down the bugs you hit while following Part II and submit them under community/eng/.

    View prompt
    Clone https://github.com/datawhalechina/zero-to-sglang and read the PR requirements in community/eng/. Draft a build-log file in community/eng/ for <chapter-name> that lists each bug, its cause, and the fix. Verify that the file follows the PR requirements before opening the pull request.

  • Run SQL against your warehouse from the terminal

    Use dct query to test a metric query, or run a named board query, before you build a chart.

    View prompt
    In the dbt-charts repo, run `dct query <placeholder> 'SELECT …'` with the SQL for the metric <placeholder> and print the result rows. Verify that the row count and totals match a known figure from your source system.

  • Add an integration for a new coding agent

    Clone the repo, run the checks, and build a new Agent integration beside the built-in ones.

    View prompt
    Using the deer-workflow repository (deerwork-ai/deer-workflow), read the public Agent interface and the ClaudeAgent and PiAgent integrations, then draft a new Agent integration for <target coding agent>. Expected output: a pull request branch with the new integration. Verify that bun run check passes before you report the work as done.

  • Build an acceptance bundle for an outside human signer

    Generate an Acceptance Bundle from a ledger so an external Acceptor can sign without a private key entering the tool.

    View prompt
    Using https://github.com/dengyier/OpenWorkProof, run `owp acceptance-bundle-build <LEDGER> <SURFACE> --evidence-root <PATH> --output <DIRECTORY>` and then `owp acceptance-bundle-verify <DIRECTORY>`. Report the exit code and whether it is 0, 2, or 4. Verify that no private key or acceptance receipt was generated by the tool itself.

  • Replay a labeled evaluation set without network calls

    Re-run a labeled ranking dataset locally to compare policies without spending provider calls.

    View prompt
    Using the Dicklesworthstone/skillranker repo, run `sr eval --dataset <evaluation file> --explain`. Expected output: replayed decisions with explanations and no network requests. Verify that the replay reports no provider calls and that the labels in the dataset match the outcomes you expect.

  • Upgrade an old DSH plugin to a new DSH release

    Use an upgrade skill pack so Claude Code or Codex can migrate a plugin to a newer DSH version.

    View prompt
    Using the upgrade skills in github.com/oh-my-dsh/dsh-plugin-upgrade-skill, migrate the DSH plugin at <plugin-path> to the target DSH version <target-version>. Report the list of breaking changes applied and the test result. Verify by running the plugin's tests and confirming they pass.

  • Load bot-protected pages that block default browsers

    Use Bladebro's stealth layer to load sites with anti-bot protection.

    View prompt
    Use the bladebro MCP server to open <protected site URL> and return the main page content. State whether a challenge or block appeared, and verify that the content matches what a normal visitor would see.

  • Trace untrusted input in a system you are authorized to test

    Have AlphaCode trace input to sensitive operations and confirm which findings reproduce.

    View prompt
    Use the dragonked2/alphacode repo to trace untrusted input to sensitive operations in <authorized target path>. Report only findings that you reproduced in the authorized test environment, with the reproduction steps. Verify each reported issue by re-running its reproduction once.

  • Tighten capture rules after reviewing a day

    Use the record to set rules that stop capturing apps, sites or text you do not want kept.

    View prompt
    In the dragthelake/ambient-context app, use the tune rules skill to review the Context records for <placeholder date> and propose capture rules for apps or sites that should not be kept. Expected output: a short list of proposed rules, each naming the app or site and the action. Verify each proposal against the block it came from before applying it.

  • Build and run Waku from source for development

    Set up the Rust and Bun toolchain and start the development app from a local checkout.

    View prompt
    In a local clone of egoist/waku at <clone path>, install dependencies and start the development build. Expected output: the Waku Debug app launches and the daemon is at target/debug/waku-debug-daemon. Verify the daemon binary exists at that path after startup.

  • Rerun the gateway benchmark on your own AWS account

    Use the bench harness to measure Antirion overhead against your own setup.

    View prompt
    Using the eliasbiondo/antirion README and docs/benchmarks.md, prepare the bench/ harness for <AWS region> following the reproduction steps. Expected output: a results summary with overhead p50 and p99 and error rate. Verify that the load generator and upstream run on separate machines as the method requires.

  • Explore synthetic agent runs without installing anything

    Open the hosted demo and follow the 30-second walkthrough on synthetic runs.

    View prompt
    Open the hosted TraceCrate demo at https://fankchen.github.io/tracecrate/ and follow its walkthrough on the two synthetic pagination runs. Expected output: a short summary of the Timeline filters, the Compare differences, and the redacted export preview. Verify that the summary does not describe the demo labels as measured results.

  • View and operate a remote desktop from your phone

    Open a computer's graphical desktop in a floating window and use touch to check apps.

    View prompt
    Using the farlume/termish README and its screen service guide, explain the requirements for viewing the remote screen of <host>. Expected output: a list covering the graphical session, the companion service and macOS recording consent. Verify that the list mentions that lock-screen capture is limited by the desktop's security policy.

  • Export recording data to dataframes for computation

    Load a Dalaran recording into a dataframe to compute on it instead of viewing it.

    View prompt
    In the Flaminis/Dalaran repository, install dalaran-sdk and load <recording_path> into a dataframe using the dl_dataframe view. Expected output is a table of rows for each logged entity and timeline value. Verify that the row count matches the number of frames logged in the source run.

  • Open the live graph over a Herdr agent pane

    Press one key in Herdr to open the exact session running in a pane as a live graph.

    View prompt
    In the zoetrope repo (furkankly/zoetrope), install the herdr-plugin with the Herdr commands in its README, then focus the agent pane <pane-name> and press prefix+shift+z. Expected output: the live graph of that pane's session opens over the pane. Verify that the graph matches the session running in that pane before reporting success.

  • Summarize unread articles with AI Radar

    Use AI Radar and article summaries in Tidings to triage a backlog of unread feeds.

    View prompt
    Using the tidings-rss repo and Tidings, import tidings-top200.opml and open Daily AI Radar. Return the grouped headlines and the source links they cite, and confirm each link opens the original article.

  • Trace top broker buying and selling in an IDX stock

    See which brokers lead buying and selling in one ticker and whether a bandar phase is showing.

    View prompt
    Use the idx tool from the fzn0x/idx repo to run `idx broker <ticker>` and `idx bandar detect <ticker> --period 1w` for <ticker such as BBCA>. Return the top buyers, top sellers and the accumulation or distribution read. Verify that the output reports the session date and states whether the phase is accumulation or distribution.

  • Keep one character consistent across new scenes

    Reuse a character reference file to place the same person or mascot into several new scenes.

    View prompt
    Using GPT Image Skill in <repo path>, generate <number> scenes using <character reference path> as the reference in each job, with the scene descriptions <scene list>. Expect one PNG per scene under /generated-images. Verify the reference file is attached in every job, not replaced by a text description.

  • Connect Claude Code or Cursor to GenOffice over MCP

    Start the Genoffice MCP server so an MCP client can create and edit Office files with no window open.

    View prompt
    Connect Claude Code to the GenOffice MCP server using the `claude mcp add` line from Settings → Integrations, then create a one-page .docx named <file name> in <folder>. Expected output: the .docx file and a list of the tools used. Verify that the file opens in Word.

  • Refit all 582 controller parameters from trajectories

    Retrain the controller from released offline trajectories without a backbone pass.

    View prompt
    In the repo GongZhiren/State-of-Thought, install the package and run sot train with experiments/paper/llama-3.1-8b.yaml. Report the output controller path, run sot checkpoint verify on it, and state whether its parameter count is 582.

  • Create an instrumental song from a genre and topic

    Use the song pipeline to get a researched genre, checked score, MIDI and mastered track you can review.

    View prompt
    Using GTKottman/mortiflix-oss, create a song project for the genre <genre> and the topic <topic> with `mortiflix new song` (inferred command). Run `mortiflix run` and report the blueprint gate. Verify that the output includes a blueprint review before the final track.

  • Back up your whole agent workspace and restore it

    Seal a backup with a passphrase, check it, and restore it without losing what it replaces.

    View prompt
    Using the Bloks repo at hamedgitty/bloks, create a sealed backup of the workspace and check it. Expected output: a backup file that the check reports as valid. Verify that the check passes and that you have the passphrase stored outside the backup.

  • Plan heavy model work around peak and off-peak pricing hours

    See which hours are peak and get a popup or system alert before pricing switches.

    View prompt
    Using the dsh-cost-meter plugin in DeepSeek Harness 0.2.0 or later, report whether the current UTC time is peak or off-peak and the next switch time. Verify the result against the peak/off-peak hours display in the plugin.

  • Add Browser Agent and Code Agent through MOVO Desktop

    Connect the separately distributed desktop app to your self-hosted service for browser and code work.

    View prompt
    Using the repo himovo/movo, deploy the self-hosted service with ./movo up, then install MOVO Desktop and connect it to <MOVO service URL>. Report whether Browser Agent and Code Agent appear and verify that a sample browser task completes.

  • Block bad commits with lint and version drift checks

    Run the bundled lint, skill drift, and version checks so broken rules or mismatched versions never get committed.

    View prompt
    In the agentic-playwright repo, run `npm run check:skills-drift`, `npm run check:skills-references`, `npm run check:version`, and `npm run skills:verify`. Expected output: each command exits with a clear pass or a non-zero drift error. Verify all four exit with status zero before reporting success.

  • Fine-tune an ACE-Step LoRA on your own tracks

    Upload audio, auto-label it, review the labels, train a LoRA adapter and use it on the generation form.

    View prompt
    Using the repo inikolax/remiqora, create a LoRA dataset from the folder <dataset folder> with the trigger word <trigger word> and train an ACE-Step adapter. Expected output: a finished adapter listed in the ACE-Step LoRA list. Verify that the adapter appears in the list and that a short test generation with it sounds different from the base model.

  • Build the Lody iOS client from source for local development

    Clone the monorepo, install JavaScript and CocoaPods tooling, and prepare an iOS build.

    View prompt
    Using the Innei/lody-ios repo README, produce a setup checklist for building the iOS client from source on macOS. Replace <target-folder> with the folder where the user wants the clone. Expected output: an ordered checklist with the exact commands, and a note on where the CocoaPods bundle goes. Verify that the Node.js and Xcode versions match the README.

  • Find which of your past posts actually worked

    Rank your published posts by engagement rate and reach multiple, not raw impressions.

    View prompt
    Use the li-audit skill from https://github.com/Jakeschincariol/linkedin-agent-skill on the post data I paste from <source of post data>. Expect a ranking by engagement rate and reach multiple, with a short note on each. Verify that every number in the output comes from the data I supplied.

  • Run Percho from source to customize its themes

    Install dependencies, start the dev build, and run the checks before changing the UI.

    View prompt
    Using the repo Jaxton07/percho, install dependencies and start the development build, then run `npm run typecheck` and `npm run test`. Report the results and confirm the three packages (shared, backend, desktop) are present.

  • Build a Spark cluster from your own machines

    Enroll several machines as workers and run Spark jobs on the combined Standalone cluster.

    View prompt
    Use the open-lakehouse-compute-fabric repo (jddevtime/open-lakehouse-compute-fabric). Install the Spark runtime with `olcf runtime install --with-jdk`, enroll <number of machines> workers, and report the cluster members. Verify that a test job runs and that the worker list shows each machine as enrolled.

  • Link research notes with wikilinks and attach PDFs and images

    Connect notes with wikilinks, review backlinks and the graph, and drop source files into notes.

    View prompt
    In an opensidian vault at <vault-path>, list the notes that contain [[wikilinks]] to <topic-note>, and report the names of notes that link back to it. Verify that each reported link target exists as a file in the vault before listing it.

  • Deploy the full Tracely stack to Railway in one click

    Run the API, worker, UI, Postgres, ClickHouse, Redis and MinIO on your own Railway project.

    View prompt
    For the Tracely-ai repository, use the Railway deploy template linked in the README, generate SESSION_SECRET and SECRETS_ENCRYPTION_KEY with `openssl rand -hex 32`, and report the frontend domain once the deploy succeeds. Verify that the frontend loads and that you can create a workspace before finishing.

  • Run deterministic evals on the collaboration workflow

    Run the versioned fixtures and see the pass count for the verified workflow.

    View prompt
    In the jzjzzzzzzz/agent-me repository, run the collaboration evaluator with the verified workflow in JSON mode. Return the pass count and any failed case IDs. Verify that rerunning the same command on unchanged code gives the same result.

  • Move an existing CadQuery script into SOMA

    Open a CadQuery script in SOMA, let the agent extend it, and export it back as a script.

    View prompt
    In the SOMA model folder for <model name>, import the CadQuery script at <script path> into the model, make the change <change description>, run `soma build`, and report whether the build succeeds. Verify that the exported script still produces the same part geometry.

  • Run the Kition web client from source for UI work

    Clone the public client and start the fast web preview for renderer and component changes.

    View prompt
    In the kition repository at <local path>, run `pnpm install --frozen-lockfile` and then `pnpm dev:web`. Report whether the web preview starts and the local URL it prints, and confirm no runtime source is needed.

  • Automate a small daily phone chore from the command line

    Run a Wi-Fi toggle or a value check on the phone on a schedule from your PC.

    View prompt
    Using the Droidline repo at https://github.com/KnifeLemon/Droidline, run the command line steps to open the Wi-Fi setting on the paired phone and toggle it off, then save a screenshot to <path>. Verify the screenshot shows the toggle in the off state and report the result.

  • Scan pull requests in CI with Perch Cloud

    Have Perch review pull requests automatically, with no workflow file to write.

    View prompt
    For the perch repo at <project path>, read https://docs.perchscan.com/ci/ and summarize what a build can gate on. Confirm that a test pull request receives perch findings. Verify that the pull request shows findings without any new workflow file added to the repo.

  • Expose local audio generation as an API and MCP server

    Run Yovoice serve so Cursor or Claude Code can call the authenticated HTTP API and MCP inference service.

    View prompt
    Using the leemysw/yovoice repo, run `yovoice serve` on <host machine> and connect Claude Code or Cursor to its MCP endpoint following docs/api.md. Expected output is a short test audio clip returned by the agent; verify that unauthenticated requests are rejected.

  • Find and import a Poly Haven asset after approval

    Ask the assistant to search Poly Haven for an asset that fits the scene and import it only after you approve.

    View prompt
    Using the mcp-for-blender-pro repo, ask the assistant to search Poly Haven for an asset matching <scene description> using search_assets and ask for approval before calling import_asset. Return the asset name, its license and the import result, and verify that the asset was not imported before approval.

  • Run scheduled record syncs on a home server

    Use the headless Docker image to keep your local library current without a desktop session.

    View prompt
    Using the ZeppBridge repository, read the Docker guide and list the files needed to run a headless sync on <server name>. Expected output: a checklist of files and where to place them. Verify that the checklist treats auth.json and the token as secrets to keep off shared storage.

  • Shortlist verified official agent skills

    Pull the Official 100 list to pick skills published by verified publishers on each registry.

    View prompt
    Open rankings/official-100.csv in the LinklyAI/best-skills repo from the newest dated folder under data/. List the first five skills with their vendor and Verified by value. Verify that every row you list has a non-empty Verified by value.

  • Set up a source build to contribute to OpenChart

    Clone the repo, install the pinned toolchain, run the app from source, and run checks before a pull request.

    View prompt
    In the openchart repo, make the change described in <issue link> and prepare a pull request. Expected output: a branch with the change and a passing `just check` run. Verify that `just check` passes before you open the pull request.

  • Run the test suites and dev servers after changes

    Check backend and frontend tests and start hot reload servers while editing the code.

    View prompt
    In the aurelio-finance repository, run `uv run pytest` in backend/ and `npm test` in frontend/ on <target branch> and report the pass and fail counts for each. Verify that both commands exit with success before reporting the branch as ready.

  • Get call transcripts and to-dos without a meeting bot

    Record a call from your Mac with no bot in the meeting, then get a transcript, summary and to-dos.

    View prompt
    Using the Louis-CFM/coucou repo, set up the Notetaker in the Coucou Mac app on <target Mac> to record a call and write a summary with Claude or Apple Intelligence. Expected output: a transcript by person, a summary and a to-do list. Verify that the audio file is removed after the transcript is written.

  • Let the agent pay with a one-time card

    Approve each purchase with a single-use card from your Stripe Link wallet.

    View prompt
    In the open-instinct repo at <repo path>, read docs/PAYMENTS.md and the spend policy file, then summarize the limits. Expected output: the ask-above amount, the daily cap and the always-ask items. Verify that the summary says the agent never holds the card number.

  • Watch Command Code 5-hour and weekly limits in the sidebar

    Turn on the quota card to see your plan and both usage windows next to Settings.

    View prompt
    Enable the quota card for the Mars-Sea/dsh-commandcode-provider plugin in the <profile> dsh profile and confirm the sidebar card appears above Settings. Expected output: the plan name and the 5-hour and weekly progress bars. Verify that the card disappears again when the switch is turned off.

  • Launch a paid landing page with Stripe and Google Ads

    Have the farm build a page, make a Stripe price and start a search campaign, with you approving each charge.

    View prompt
    Using the clodfarm repo at github.com/matank001/clodfarm, connect Stripe and Google Ads through CONNECTORS, then ask the farm to build and deploy <product landing page> with a <price> plan. Confirm the Stripe price and payment link exist, and confirm the campaign is drafted and not started until I approve it.

  • Plan a huge project as a map of decision tickets

    Use wayfinder to resolve decisions one at a time across several agent sessions.

    View prompt
    In the mattpocock/skills repo, use wayfinder to map the work needed to reach <destination>. Expected output: a set of decision tickets on the issue tracker and the first one to resolve. Verify that each decision ticket is stored in the tracker and not only in the chat.

  • Keep game touch controls clear of the fold

    Check a game's screen filling, aspect ratio and on-screen controls against iPhone Duo poses.

    View prompt
    Using the iphone-duo-games skill from mirzaaghazadeh/iphone-duo-skills, review <path-to-game-project> for how the game fills the screen across poses, handles aspect ratio and letterboxing, and places on-screen touch controls. Output the changes needed, and verify that no touch control is placed across the fold in any listed pose.

  • Let a coding agent install the skill and run Jev Lint

    Install the Jev Lint skill so an agent can run checks and write project rules.

    View prompt
    In the repository <repo-path>, install the skill with `npx skills add mizchi/jev-lint --skill jev-lint`, then run `npx jev-lint check src --dry-run` and report the planned request count and price. Only after a human approves, run `npx jev-lint review --base main` and list findings with file, line and score.

  • Add Context Mode to Gemini CLI with one settings file

    Install the npm package and register the MCP server and four hooks in settings.json.

    View prompt
    Install context-mode globally with npm, add the Gemini CLI settings from the context-mode README to ~/.gemini/settings.json, then run /mcp list in Gemini CLI. Report whether context-mode shows as Connected and list the four hooks that are registered.

  • Verify the live Digikala MCP server before relying on it

    Run the bundled check to confirm the endpoint, tool list and error paths still work.

    View prompt
    Clone https://github.com/mmdju/digikala-mcp and run `node scripts/verify-live.mjs` against the live endpoint https://digikala-mcp.mmdju.workers.dev/mcp. Report each check (handshake, release, tool list, search with details, error paths) as pass or fail. Verify that the tool count matches the 19 tools listed in the README.

  • Map IPC channels and preload bridges in an Electron app

    Use hexvero to scan an Electron archive for IPC channels and window settings.

    View prompt
    Using the morluto/awesome-reverse-engineering list, summarize what hexvero reports for <electron-archive> and list the IPC channels and preload bridges it finds. Expected output: a table of channels with their source files. Verify that the report notes the limitation about indirect code.

  • Apply Prismantis styling to Codex output

    Follow the Codex guide to get themed code, tables and diagrams in Codex sessions.

    View prompt
    Read codex/README.md in the NahumLitvin/prismantis repository, install prismantis for Codex as that file describes, then start a Codex session and request a markdown table. Expected output: a table with a themed header row. Verify the output against the list of what works today in that file.

  • Spot logic implemented more than once across projects

    Run the duplicate-implementation report to find copies and mark the canonical version.

    View prompt
    Using the session-knowledge repo, call list_duplication and review the output for <capability> across projects. Expect a list of repeated implementations and any projects marked as forks. Verify each flagged duplicate by opening the file before proposing a canonical version.

  • Write or revise fiction with the Hemingway voice profile

    Apply the built-in Hemingway voice to a story with an opt-in direct entry.

    View prompt
    Using the sepia repo, run its hemingway operation on <scene file path>. Expected output: the scene with the Hemingway voice applied and a review of the profile's known costs. Verify that the story's facts and character names are unchanged.

  • Port the GPT with Taste recipe to a new coding host

    Adapt the single recipe to a harness not in the supported list.

    View prompt
    Read docs/harnesses/porting.md and docs/authoring.md in the gpt-with-taste repository at <repo-path>. Produce a short plan for adapting the recipe in recipe/ to <target-host>, listing the instruction loading step and the steering events to hook. Verify the plan against the existing Claude Code and Pi integration docs.

  • Port the skills to a harness you already run

    Point the skill and model settings at your own agent harness through environment variables.

    View prompt
    Using the VulnHunter repo at nealbridges/VulnHunter, configure the environment variables VULNHUNT_SKILLS_DIR, VULNHUNT_AGENTS_DIR, and VULNHUNT_MODEL for my harness, then run /vulnhunt on <test repo path>. Return the configuration used and whether the skill loaded. Verify that the run used the model I set and not a hardcoded default.

  • Report a technical error or broken demo in a chapter

    Open a well-described issue so the correction can be made and credited.

    View prompt
    For the NiluK/worldmodels101 course, draft a GitHub issue about <chapter name and problem>. Include the chapter number, the quoted text, the expected correction, and a source link. Verify that the issue text contains no claim you cannot support with the source.

  • Query your bank with a local Ollama model

    Bridge a local Ollama model to BankMCP so no AI vendor sees your transactions.

    View prompt
    Using the repo noskillish/bankmcp, run `npm run chat -- "<question>"` with the Ollama model qwen3:8b. Expected output: an answer that lists the balance for each linked account. Verify each per-account balance against the bank app before trusting any total.

  • Keep speech models loaded in a worker process

    Run a long-lived speech worker that a program talks to over JSON Lines.

    View prompt
    Using the nyosegawa/speech.cpp repo, install speech, start `speech worker <model-name>`, and send one JSON Lines request built from docs/worker.md for the input <path-to-wav>. Expected output: one line of text or audio followed by a terminal message on stdout. Verify that the terminal message arrives for every request you send.

  • Test the ESP32 board over BLE from a Mac

    Play the app's role from a Mac to check the board's BLE link, hotspot and HID output.

    View prompt
    Using the repo onehumanbeing/esp32-iphone-agent, run hardware/tools/board_test.py against the board at <serial port> and summarize each BLE command it sends. Expected output: a list of commands with pass or fail. Verify the protocol names match docs/ble-protocol.md.

  • Give a coding agent cheap web reading in one step

    Install the web-browsing skill and add one line to your agent instructions file.

    View prompt
    Use the only-cli/oc repo: after the skill and instructions line are in place, ask the agent to read a page using `npx @only-cli/oc open <url>`. Expect a numbered compact view with an actions line. Verify the agent used oc instead of a raw fetch.

  • Replay a browser flow and check the evidence it shows

    Run a UI case in Playwright Chromium and get a report with marked screenshots per step.

    View prompt
    Use codexqa-jev-browser to replay the case at <case-path> against <target-url>. Write a report under reports/<run-id>/report.html with a marked screenshot per step. Verify that the final screenshot shows the visible evidence named in the goal.

  • Study an idempotent inventory tool integration

    Use the inventory example to see how a business tool commits once and recovers lost responses.

    View prompt
    Using the repo OpenSparX/MasterAgent, open examples/inventory_agent/README.md and run its integration test. Expected output is a passing test showing UNKNOWN recovery and no second stock decrement. Verify that the test covers a response dropped after commit.

  • Set up Open Vetta from source and run the desktop app

    Clone the repo, install dependencies, and start the desktop app in development mode.

    View prompt
    Clone openvetta/open-vetta, switch to the dev branch, run bun install, and start the desktop app from apps/desktop with bun run dev. Report whether the app launches and which data folder it uses. Verify that the data folder is ~/.vetta-dev and that the installed-app folder ~/.vetta was not changed.

  • Chat with a ChatGPT or Grok plan you already pay for

    Sign in with a ChatGPT or Grok subscription instead of an API key, using the provider's device flow.

    View prompt
    In the oriveo/oriveo repository, run the web client with npm run dev:app and start subscription sign-in for <provider-name>. Expected output: a device code and verification step from the provider. Verify that the chat completes after approval and that no API key was entered.

  • Run several bot personas from separate deployments

    Create isolated deployment folders so each persona has its own config and memory.

    View prompt
    In the Cortico repo at <path>, create a new deployment with `pnpm start --new` and then start it by name. Expected output: a second deployment directory under deployments/ that starts separately. Verify that the first deployment is unchanged after the second one is configured.

  • Have a coding agent generate part variants from briefs

    Let an agent set the brief, run the pipeline, and return exported part files for each variant.

    View prompt
    Use the Multi-Agent-CAD repo (github.com/Pan-Chera/Multi-Agent-CAD). For each brief in <list of briefs>, set USER_REQUEST in multi_agent_cad/config.py, run python -m multi_agent_cad.graph, and return the STEP and STL paths with QA results. Verify that each output matches its brief dimensions before reporting.

  • Use the server as a text classifier endpoint

    Send labeling and classification requests to the local model through the classify endpoint.

    View prompt
    Using the repo peonist-ai/halogen-flash-server, send the texts in <input file> to the classify endpoint as described in docs/CLASSIFY.md. Expected output: one label per input text. Verify the labels on ten known examples before running the full batch.

  • Cut sandbox start time with warm pools and snapshots

    Keep booted sandboxes ready or restore from a base snapshot to skip cold boots.

    View prompt
    In the perplexityai/SPACE repo, read docs/warm-pools.md and docs/base-snapshots.md, run `space-admin-cli login`, and configure a warm pool or base snapshot for <target node or cluster>. Report the configuration you applied and the create result. Verify that a new sandbox is created from the pool or snapshot as the guide describes.

  • Let Claude Code read PostgreSQL findings over MCP

    Connect an AI coding agent to structured database findings through the Pgbot MCP server.

    View prompt
    Using the pgrundev/pgbot MCP server running against <target-db-url>, fetch the current health findings and list each CRITICAL and WARNING finding with the table, query, or index it names. Verify that the response includes the contract version 1.5.0 before you act on any finding.

  • Speed up chat replies with draft tokens

    Enable draft decoding for supported Qwen and Gemma models to get faster chat replies.

    View prompt
    In the janas repo, start ./janas-chat --mtp with Qwen3.6-35B-A3B selected and ask it to explain how bread is made at home. Report the tokens-per-second shown and confirm the reply is complete.

  • Watch and steer agents from one local board

    Open the Pullboard View to see what needs your decision, follow item history and export a snapshot.

    View prompt
    In the repo <path> with Pullboard set up, run `pullboard view` and list the items under Needs you. Then run `pullboard view --export` and report the file it writes. Verify that the snapshot contains the same items shown in the live view.

  • Rebuild the figure dataset with the curation pipeline

    Run the documented scripts to regenerate the gallery data from proceedings and PDFs.

    View prompt
    In a clone of qwdwqfwq/topconf-paper-figure-gallery, install requirements and run the build_pool, extract_all and score_select scripts in that order for a dry run on <venue>. Expected output: a selection count printed by score_select. Verify the count is non-zero and that no figure is copied from the gallery without its source link.

  • Look at a vibeX demo before installing anything

    Run the demo command to see sample diagrams without installing the tool.

    View prompt
    Run npx @vibex/vibex demo out in an empty directory and list the files created in out. Verify that at least one HTML file opens from disk without a server.

  • Self-host the scan server on your own GPU or Modal

    Run the full Open Reality server on your own GPU box or Modal account, with no account needed.

    View prompt
    In the openreality repo, follow server/docs/self-hosting.md to start the server at <path or Modal target> and connect the MCP client using OPENREALITY_URL=<your server URL>. Verify that the MCP client can reach the server and that the token printed at first start is not committed to any file in the repo.

  • Run Talorys locally to test changes without Cloudflare

    Start the agent, Pages proxy and UI on your machine with a mock AI provider.

    View prompt
    In the rociiu/talorys repo, run `npm install` and `npm run dev`, then open http://localhost:5173. Report whether the sign-in page loads and whether `npm test` passes. Verify that the app is running without a Cloudflare login.

  • Split one goal across a flock of simulated robots

    Give a flock a goal so each robot's model divides the work by messaging the others.

    View prompt
    Using the rokbenko/quackd repo, register two simulated robots as <robot-a> and <robot-b>, group them into a flock named <flock-name>, and run the goal "Split the search, the closest duck kicks." Report which robot kicked and the calls each robot made. Verify that both robots received their own model pilot and that the goal completed.

  • Schedule recurring agent tasks with natural-language prompts

    Set up one-off or repeating agent jobs and review their execution logs.

    View prompt
    Using the Grok App repo (https://github.com/RongleCat/grok-app), create a scheduled automation for project <project-name> that runs the task <task-description> on <schedule>. Expected output: an automation entry with an execution log after its first run. Verify the permission mode before the first scheduled run.

  • Build a Dispute and Recovery Pack from a recount

    Turn recount findings into a Dispute and Recovery Pack, then record what the vendor actually conceded.

    View prompt
    Using the AgentMeasure repo, use the existing recount findings to run `agentmeasure dispute` and summarize the resulting pack. Then run `agentmeasure recovery` with the vendor concession, and verify that the recorded amount is kept separate from the original claim.

  • Add the Grok Build project surface to a repo

    Write Ruflo's Grok host files into one project, previewing first with a dry run.

    View prompt
    Using the repo ruvnet/ruflo, preview then write the Grok Build project surface into <project path> with `npx ruflo init --grok`. Expected output: a .grok/ folder and team bus files inside the project only. Verify that no files were written outside the project directory.

  • Send a follow-up to an AI agent running in your terminal

    Say an instruction and Atticus types it into the terminal window while you keep working.

    View prompt
    Using the repo SaarthurR/atticus-mac, ask Atticus to tell the agent in the terminal window to <instruction>. Expected output: the instruction is typed into that terminal window. Verify that the window received the text and that Atticus confirmed the send or asked for the window.

  • Build a short film from a JSON recipe

    Turn a JSON recipe into shots, a timeline, a review scene and an exported video.

    View prompt
    Using the scenario-labs/blender-plugin Film tasks feature in Blender 5.0 or later, build shots and a timeline from the JSON recipe at <recipe path> and export a video. Report the shot count and the export path. Verify that the review scene and exported video both exist.

  • Check prices before running a generation batch

    Have an agent price a planned batch in Scenario before spending credits on it.

    View prompt
    Using the scenario-labs/skills repo, price a batch of <count> generations described in <batch-file> before running any of them. Report the total cost and the cost per item. Verify that no generation starts until I approve the total.

  • Outline a port of another TTS model to vLLM-Omni

    Use the Breeze integration as a worked example to plan a new model's adapter and request handling.

    View prompt
    Using the repo Sentinel3252/Native-Breeze-TTS-2-Support-for-vLLM-Omni, read the final article in docs/learning/ and docs/architecture.md, then produce a porting checklist for <target TTS model>. Each item must name the matching Breeze file or test, and the output must flag any step the repo does not cover.

  • Write a custom WebGPU component with defineShader

    Define a new effect with props and a WGSL pixel function, then mount it like any other component.

    View prompt
    In the shader-effects-inc/shaders repo, write a custom defineShader component named <component-name> in <project-path> that draws <effect-description>. Expected output: one new component file and a page that mounts it. Verify that the wgsl paint block returns a vec4f and that the props match the defaults.

  • Check failed experiments before planning a training run

    Read the published failed experiments to avoid repeating dead ends.

    View prompt
    In the Shanghua-Gao/RSI-Jev repo, read EXPLORE.md, docs/history.md and docs/rl.md and list every experiment that relates to <topic>. For each one, return the result and the failure reason as written in the repo. Verify that each item cites the file where it appears.

  • Branch a run from a checkpoint to try another path

    Create a checkpoint, then branch from an earlier point into a separate world.

    View prompt
    In Infinite Pokémon, create a checkpoint in a run, branch from it, and report whether the branch has its own world database and whether later events from the original run appear in it. Note any generation status shown for unfinished destinations.

  • Add drawn eyes and mouths with Codex

    Have Codex draw closed eyes, vowel mouths and expressions so blinking and talking look more natural.

    View prompt
    In the mesh-avatar-studio repository, use Codex to draw the eye and mouth variants for <project name> as described in the copied editor message. Expect the drawn variants imported into the project. Verify that the editor reloads them and that blinking and vowel mouths use the new images.

  • Test where a printed part will bend or break

    Run a voxel stress simulation to see where a load concentrates and the weight the part breaks at.

    View prompt
    Using the nurb repo (Shpigford/nurb), run `nurb stress` on <target part name> and report the peak MPa, sag, and margin to breaking. Expected output: those three values. Verify by running `nurb check` on the same part afterward to confirm it still passes.

  • Make a runtime change and pass the repo's checks

    Set up the git hooks, make a Python change, and run the format, lint and test targets.

    View prompt
    In the Sidiora-Labs/centra-gideon-agent repository, make the change described as <change> under runtime/gideon, then run make format, make lint and make test. Report the changed files and the final test result. Verify that make lint and make test both finish with no errors before you report the change as ready.

  • Generate release notes from git history

    Build a changelog grouped by commit prefix, with optional model-written highlights.

    View prompt
    In the Hyperfide repository, run `hyperfide changelog` and report the number of releases and the groups used. Verify that each task reference from the commit history appears in the output.

  • Review nightly lessons from your own sessions before they stick

    Let the nightly loop propose lessons and skill changes, and accept only the ones you want.

    View prompt
    In the repo <repo-path>, run the rem-reflect skill from Sno Station Skills over the last <day-count> days of Claude Code and Codex sessions. Output a list of proposed lessons and skill changes, each with the session evidence. Verify that no change is applied until it is explicitly accepted.

  • Prepare a booking or order and approve payment yourself

    Have an agent fill in a site, stop at login or checkout, and let you approve each payment.

    View prompt
    Using the open-source repo SouravBeraAkaSpeed/xiryn, ask a Xiryn agent to prepare a <booking or order> on <site>, stopping before payment. Expected output: a prepared booking or cart with a payment approval request. Verify that the agent asks for approval before any payment is made.

  • Run the router from a menu-bar app with no setup

    Install the desktop app and use the tray popover key with any OpenAI-compatible client.

    View prompt
    Install the freellmapi desktop app from the GitHub Releases page for tashfeenahmed/freellmapi, add provider keys, then copy the unified key from the tray popover. Expected output: a successful reply in <chat-app>. Verify that the tray popover shows a request count increase.

  • Run Linux commands and scripts on your phone

    Use the in-app terminal to run shell commands in a private Ubuntu 20.04 environment.

    View prompt
    In the Mobile Harness Terminal on an ARM64 Android phone, run `git --version` and `node --version`. Expected output: version strings for Git and Node.js from the Ubuntu subsystem. Verify that both commands return a version without errors.

  • Turn a plain-language request into a ready-to-run command

    Use Prompt Enhancer to convert a free-form audio request into a complete auk-infer command and manifest.

    View prompt
    In the Tencent-Hunyuan/AuK repo, set the OpenAI-compatible LLM variables from .env, then run src/auk/infer/pe.py on <input.wav> with the request <plain-language request>. Verify that the printed auk-infer command and the JSON manifest under assets/after_pe/ are created, then run the printed command only after checking its output path.

  • Add image and video generation to an agent with Volcengine Ark

    Enable generate_image and generate_video tools that save output into the agent workspace.

    View prompt
    In the TencentCloud/octop-harness repo, configure HarnessAgentConfig with MediaGenerationConfig using api_key_env="ARK_API_KEY". Ask the agent to generate an image of <subject>. Verify a new file appears under generated/images/ in the workspace.

  • Export a Paperclip company and import it on another machine

    Package a whole agent department and move it to a different Paperclip install.

    View prompt
    Using the repo theNetworkChuck/paperclip-guide, follow chapter 10 to export the company from <source install> and import it into <target install>. Report the agent count and task count in both installs. Verify that the counts match and that agent approvals still apply after import.

  • Find photos by describing them, on your own computer

    Search a photo library in plain words without tagging or uploading anything.

    View prompt
    Using the repo thesnarkitecht/rembrandt, turn on Smart search in Preferences and search the library at <folder-path> for <description>. Report the number of matching photos and confirm that no photo or search text was sent off the computer.

  • Render streamed OpenUI in a Vue, Svelte, or Angular app

    Install the matching runtime to render OpenUI Lang output in a non-React front end.

    View prompt
    Using the thesysdev/openui repo, install the matching runtime for the project at <target project path> (vue-lang, svelte-lang, or angular-lang) and render one streamed OpenUI Lang response. Expected output is a visible model-generated component; verify that it appears progressively rather than all at once.

  • Review what the sleep-time pass changed and proposed

    Check the dream report and dream status to see what consolidation added, updated, or proposed to delete.

    View prompt
    Inside the agent-memory store at <store path>, run `mem --json dream-status` and read the latest file in dream-reports/. Return the Dream state, the list of moved memories, and any proposed deletions. Verify that no deletion is applied unless it was confirmed.

  • Review one file's full history of changes in file-scope mode

    Open a single file in Reslop to review it outside the diff, with editor mode.

    View prompt
    Using reslop in the repository at <repo-path>, open the file <file-path> in file-scope review and list the findings you saved to the newest .plan/ file. Report the count and each finding's line. Verify that each line number falls inside the file.

  • Use one skill source for both Codex and Claude Code

    Keep one copy of the memory skills and point Claude Code at it with symlinks.

    View prompt
    On this machine, after installing the ai-project-memory skill for Codex per INSTALL.md, confirm that the Claude Code skill directory contains symlinks to the Codex skill files and not copies. Expected output: a list of each skill path with its link target. Verify that no skill file exists as a separate copy in the Claude Code directory.

  • Read agent turns and memory in a browser debugger

    Open turns, steps, transcripts, and memory in a browser to see what an agent did.

    View prompt
    In the ufo-core repo, run `make debugger` before `make serve`, then run `uv run ufoctl debugger`. Expected output: a browser view of turns, steps, transcripts, and memory. Verify that at least one turn from the workspace appears before you report success.

  • Close each month's spending from exported statements

    A money agent reads the statements you export, checks spending against budget, and flags unused subscriptions.

    View prompt
    Using the Overtime repo at ukanwat/overtime, create a money agent that closes the month from the statement exports in <folder>. Expected output: spending by category against budget and a list of possibly unused subscriptions. Verify that the totals match the sum of the exported lines.

  • Run UseAgent from source to contribute a fix

    Set up the full stack locally, run the backend and frontend, and open a pull request for a Hacktoberfest issue.

    View prompt
    Clone https://github.com/useagenthq/useagent, start Postgres with pgvector, install dependencies in every workspace listed in the README, and run bun run typecheck. Expected output: a passing typecheck and a note on which hacktoberfest issue you would pick. Verify that bun run dev:backend starts the API on port 3201 and bun run dev:frontend serves the UI on port 3400.

  • Pull context from earlier threads instead of re-explaining

    Search and read past T3 threads to recover decisions and code history.

    View prompt
    In the repo at <repo-path>, use t3_thread_search for <keywords>, then t3_thread_read on the best match. Expected output: a short summary of the decisions in that thread with thread identifiers. Verify the summary against the raw thread text.

  • Compare Jev against a chat model on the same questions

    Run identical typed questions through Jev and an LLM API to see which fits your task.

    View prompt
    Using the repos typesafe-ai/system-one-adapter-python and typesafe-ai/typesafe-sdk-python, run the same questions from <question file> through both clients. Expected output: a table of answers and accuracy per client. Verify that both clients received identical state and question text.

  • Mix narration, music, and effects into one finished video

    Build one loudness-levelled audio track from many pieces and mux it onto a render.

    View prompt
    In the veedstudio/open-edit repo, run mix-audio on the run folder <run>, then mux-audio onto the silent render. Expect final.mp4 with the mixed audio. Verify from the command output which loudness correction ran before you report success.

  • Sync Skills bundled in npm packages (experimental)

    Link Skills that ship inside npm dependencies into your project so they update with the package.

    View prompt
    In this project, run npm install -D skills <package name>, then npx skills experimental_sync -y. Report which skills were linked and confirm they came from the installed package. Note that this feature is experimental.

  • Create a routing rule from a running process

    Pick a live process in the app and turn it into a routing rule in one step.

    View prompt
    Using the Vincent-Xi08/IntentRoute-AI repo, find the running process named <process name> and create a rule for it. Expected output: one new rule that shows the real executable path. Verify that the rule was added disabled and that the configuration was saved through the normal transaction.

  • Answer agents from your phone when they need you

    Scan a QR code to browse your session tree and reply to agents from iOS or Android.

    View prompt
    Pair the VelaTerm phone app with the desktop app for the project at <project-path} by scanning the QR code shown in remote access. Expected output: the session tree on the phone with the same sessions as the desktop. Verify that a push notification arrives when an agent in that project waits for input.

  • Let a coding agent set up and launch training jobs

    Point Claude Code or Codex at the repo skills to choose parallelism and launch a Halo run.

    View prompt
    In the whitecircle/halo repo, use the skills/parallelism and skills/launch guides to choose settings for <target-config> and then run `halo launch sft` with --dry-run inside the Halo image. Expected output: a printed launch command with the chosen parallelism flags. Verify that the flags match one of the allowed EP, CP, TP, or ETP combinations before any real run.

  • Run Qwen-Image 2.1 locally with llama.cpp and GGUF quants

    Pick a GGUF quant from Q2_K to Q8_0 that fits your memory budget.

    View prompt
    Using wildminder/awesome-qwen-image, download one GGUF quant between Q2_K and Q8_0 from unsloth/Qwen-Image-2.1-GGUF that fits <memory budget> and run it with llama.cpp on the prompt <prompt>. Report the chosen quant and output path. Verify the file loaded without errors and that the output matches the prompt.

  • Restart a DSH conversation from an earlier message and optionally revert the wor

    Branch a conversation from any user message while keeping the original archived and unchanged.

    View prompt
    In DeepSeek Harness on <machine>, use the DSH Config Manager rewind feature on the user message <message-id> in the conversation <conversation-name>. Keep the original conversation archived, do not revert workspace files, and report the new branch conversation name and the original's archive status.

  • Fine-tune a Voice Mem model family adapter

    Train your own adapter on the provided training script and reproduce the default configuration.

    View prompt
    In the VoiceMem repo at <repo path>, install ms-swift==4.5.2 and bitsandbytes, then run finetune/train.py with my dataset <dataset path>. Expected output is a trained adapter. Verify the run uses the default parameters described in the README.

  • Load a less-restricted model variant locally

    Run an optional uncensored mode on GLM, MiMo or the Qwen preset for controlled red-team and research tests.

    View prompt
    In the Yamz-Labs/kyojin repo, read doc/refusal_hook.md and load the uncensored variant of <target model> following doc/models.md. Expected output: the server starts with the mode applied and returns responses to a scoped test prompt. Verify that the test is covered by an approved plan and that all requests are logged before running it.

  • Run decisions offline on a Mac with MLX

    Score choices in Python on Apple Silicon without a server, using the MLX backend.

    View prompt
    Using the LLM2Jev repo on Apple Silicon, run the offline Python API with the MLX backend on the model at <model-path>, asking a Choice question over <options> for the input <input-text>. Return the option probabilities as JSON. Verify that the probabilities sum to about 1 before reporting.

  • Find unfilled placeholders before a batch run

    Scan the prompt data for template tokens so none are drawn into the images by mistake.

    View prompt
    Read data/prompts.json in the awesome-gpt-image-2-5-prompts repo and list every prompt whose body contains a curly-brace token or a bracketed-capital placeholder, grouped by use case. Return the IDs and the tokens found for <use case filter>. Verify that the counts are 56 curly-brace prompts and 18 bracketed-capital prompts when run on the full file.

  • Run the PairTeX test suite before tagging a release

    Sync the dev environment with uv and run the unit tests, including the version check.

    View prompt
    Read the PairTeX README and docs/release-checklist.md in this repo. Run `uv sync` and then `uv run python -m unittest discover -s tests -t .`, and report the pass or fail count. Verify that tests/test_version.py passes so the version in pyproject.toml matches __version__ in pairtex.py.

  • Check how citable a page is for AI search

    Assess a page for AI-search citability across ChatGPT, Perplexity and AI Overviews.

    View prompt
    Using the marketing-os skill in the Yuzzyuk/marketing-os repo, run the geo module on <target URL> and return a citability assessment with specific edits. Verify that the report separates what was determined from what could not be determined.

  • Generate sound effects and loops for a sample library

    Describe a sound or an instrumental loop and use Stable Audio 3 to create one-shots, loops or textures for your tracks.

    View prompt
    Using the repo inikolax/remiqora, generate a sound effect described as <sound description> with Stable Audio 3 and place it on a DAW track at the project tempo. Expected output: one or more sound variants saved in the library. Verify that the sample plays in the editor and that its length matches your setting.

  • Let a coding agent query and edit your Tracely workspace

    Connect a coding agent to the Tracely MCP endpoint with an ingest key.

    View prompt
    Using the Tracely-ai repository running locally at http://localhost:8000, connect to the MCP endpoint at /mcp with the ingest key <ingest-key>. List the five most recent failing traces and report their agent names and failure reasons. Verify that the list matches what the traces view shows at http://localhost:3001.

  • Generate a new region with the region skill

    Install the region generation skill so an agent can propose new places for the world.

    View prompt
    Use the infinite-pokemon-region skill from the Shellishack/infinite-pokemon repo to prepare the next region from the immutable run snapshot for <run name>. Report which maps passed validation, which failed, and confirm that visited maps were not changed.

  • Save project decisions so the next session recalls them

    Store decisions and constraints in project memory and recall them at session start.

    View prompt
    In the Hyperfide repository, save the decision <decision text> with `hyperfide remember`, then run `hyperfide recall` for <topic>. Report which notes were returned and their order. Verify that the saved note appears in the recall output.

  • Try both recursion modes locally with no credentials

    Run the bundled demo to see parallel and sequential harness refinement before spending any API budget.

    View prompt
    In the google-research/harness2 repo on Linux with Python 3.12 and uv, create the environment, install with uv pip install -e '.[render]', and run harness2-demo --output runs/demo --k 2. Report the files written under runs/demo and summarize what each recursion mode produced. Verify that the run finished without model credentials being configured.

  • Dub a video into timed speech locally

    Generate timed speech for a video on your own machine instead of a hosted dubbing service.

    View prompt
    In the VoiceStudio repo (github.com/debpalash/VoiceStudio), dub <path to video> into <target language> using the Video dubbing workspace with timed speech. Expected output: a dubbed video file. Verify that speech starts and stops at the same points as the original dialogue.

  • Explain a technical concept as an interactive HTML page

    Generate a standalone interactive isometric figure that explains a concept like a rate limiter.

    View prompt
    Using the skill from wheresryan22/anatomy, create an interactive standalone HTML figure explaining <concept>, with real numbers from <source notes>. Expected output: one HTML file plus a PNG preview. Verify that the readout values match the numbers you were given before reporting done.

  • Scan a game install and plan a mod route

    Find the engine, version and modding route for a game you own before writing any code.

    View prompt
    In the universal-modder repo, use the game-recon skill on the game at <game install path>. Run `um scan` and `um kb search` for it, then write MODDING_PLAN.md with the engine, version, anti-cheat status and the ranked routes. Verify that the plan names the engine and lists at least one route.

  • Have an AI agent model a part through SolidCraft MCP

    Connect Claude Code to the SolidCraft MCP server so an agent builds and edits a parametric design.

    View prompt
    Using the SolidCraft MCP server from the tangency-labs/solidcraft repo, model <part description> as a parametric design with named dimensions. Expected output: a design with a feature timeline and a list of parameters. Verify by changing one parameter and confirming the model rebuilds.

  • Audit your agent in a guided terminal wizard

    Run a 10-inspection audit of your agent with a setup wizard and get a scorecard in minutes.

    View prompt
    Use the iFixAi repo at ifixai-ai/iFixAi to audit my agent at <agent endpoint or provider name>. Run the guided wizard with `ifixai setup` followed by `ifixai run`, then report the overall grade and the list of failing inspections. Verify that the reports were written to ./ifixai-results/ before you summarize.

  • Compare agent results across parallel worktrees

    Send one prompt to several agents in separate worktrees, then compare results and merge the best one.

    View prompt
    In the stablyai/orca repo context, use Orca's Parallel Worktrees to run the prompt in <task-file> across three agents, each in its own git worktree. Output a short comparison of the three diffs, naming the one to merge. Verify that each worktree is isolated by checking that the three branches differ and that the original checkout is unchanged.

  • Draw an architecture diagram for a doc or post

    Turn a plain-words description of a system into one HTML diagram file you can open in a browser.

    View prompt
    Using the diagram-design skill from cathrynlavery/diagram-design, draw an architecture diagram of <system name> showing its components and connections. Write one self-contained .html file with inline SVG. Verify the file opens in a browser and that no labels are clipped or overlapping.

  • Run a local gitai server for concurrent agent lands

    Build gitai and run the quickstart to see several agents land changes on one branch.

    View prompt
    In the repository git-ai, run `make build` and then `examples/graft/quickstart.sh`. Confirm the script reports a completed land from two agents, then run `./_build/bin/graft` and report the list of commands it prints.

  • Make a product launch video from a website URL

    Turn a product's website, brief, or script into a short launch video using the product-launch-video skill.

    View prompt
    Using the hyperframes repo at heygen-com/hyperframes, use the product-launch-video skill to create a 45-second launch video from <website URL>. Output an MP4 and a short list of the scenes used. Verify that the title and product name in the video match the text on the website.

  • Pick the best sound file from a set of downloads

    Rank candidate sound files against a text description and keep the closest match.

    View prompt
    Use the earshot repo at <repo path>. Run `earshot rank` over the files in <folder> for the description "<description>", then run `earshot match` on the top file. Report the ranked list and the match verdict (strong, plausible, weak or no match) with its z score. Verify that the reported file exists before you use it.

  • Run Claude Code on DeepSeek instead of Claude

    Point Claude Code at a DeepSeek model through Magpie with one provider key and one command.

    View prompt
    Using the yetone/magpie repository, install magpie, add the provider <provider-name> with the API key <api-key>, and run `magpie claude <provider-name>/<model-name>`. Report the output of the command and confirm that a new Claude Code session answers from that model.

  • Rebuild a feature you saw, in your own project

    Have your agent study how another app does a feature, show the evidence, then build and test your own version.

    View prompt
    Use REA to understand how <feature> works in <app>, show me the evidence, then build a similar feature for my project at <project path> and test it. Mark anything you are guessing, and verify the result matches the behavior you observed.

  • Refine an agent harness on a small LAB legal set

    Run one Propose-Probe-Compose step on a single LAB legal domain, then judge and report the result.

    View prompt
    In the google-research/harness2 repo, set up the LAB benchmark, then run harness2 --bench lab --k 1 --mode parallel --only-domains <domain> --max-tasks 1, followed by harness2-judge and harness2-report with the same flags. Report the judged result for the task and the path of the saved results under runs/. Verify that the judge and report commands used the same benchmark, k, mode, and domain as the refinement run.

  • Turn a manuscript into an audiobook in batches

    Produce narrated audio from written chapters using batch jobs on local models.

    View prompt
    Using the VoiceStudio repo (github.com/debpalash/VoiceStudio), create an audiobook from the chapter files in <folder path> as a batch job. Expected output: one narrated audio file per chapter. Verify that the first chapter's narration matches its text, including names and numbers.

  • Create a standalone SVG illustration for a landing page

    Produce a lone isometric SVG file with embedded styles for a web page or article.

    View prompt
    Using the skill in wheresryan22/anatomy, generate a dark-theme isometric SVG illustrating <concept> for <landing page>. Expected output: one .svg file with styles embedded and one PNG preview. Verify that the SVG still reads when opened on its own, without any WebGL layer.

  • Make game sprites and art with fal

    Generate sprites with fal, cut out the background and fit them for a game you are modding.

    View prompt
    Using the universal-modder repo and the fal-assets and asset-pipeline skills, make a sprite of <what you want> for <game name> with `um fal sprite`, then cut it out and fit it to <size in pixels>. Verify that the output PNG has a transparent background and the requested size.

  • Run a JSON script to export a bracket as STEP

    Use the headless CLI to run a script and write a STEP file without opening the app.

    View prompt
    In the tangency-labs/solidcraft repo, run examples/bracket.json with solidcraft-cli and write <output-file>.step. Expected output: a STEP file at that path. Verify the file exists, is not empty, and that the command exits without errors.

  • Have Claude Code run and explain the audit

    Install the iFixAi plugin so Claude Code can discover your setup, run the audit, and walk you through results.

    View prompt
    Install the iFixAi plugin from ifixai-ai/iFixAi in this Claude Code session, then run an audit on the model <model name> with judge <judge model>. Report the cost estimate the agent shows before the run, then the scorecard. Verify that the agent named the cost before billing started.

  • Review AI diffs line by line and send feedback back

    Comment on any diff line in Orca and return the notes to the agent to fix before you commit.

    View prompt
    In the stablyai/orca repo, open the worktree at <worktree-path> and send the diff annotations to the agent. Output the revised diff with each annotated line addressed. Verify that every annotated line changed or has a written reply.

  • Match diagrams to your site's brand

    Onboard the skill to your site so every new diagram uses your palette and fonts.

    View prompt
    Using the diagram-design skill from cathrynlavery/diagram-design, onboard to <site URL> so it pulls the site's palette and fonts. Then draw a quadrant diagram of <topic> and write one self-contained .html file. Verify that the accent color and fonts match the site.

  • Land conflicting agent changes with a deterministic resolver

    Use the bundled resolve.toml rules so conflicting agent lands get resolved and verified.

    View prompt
    In the repository git-ai, open examples/graft/demo/resolve.toml and summarize its deterministic rules. Then run `examples/graft/demo/acceptance-phase4.sh` and expected output is a count of landed changes; verify that it reports all 250 changes landed when the resolver is enabled.

  • Turn a GitHub pull request into an explainer video

    Generate a changelog, feature reveal, or fix explainer video from a PR using the pr-to-video skill.

    View prompt
    Using the hyperframes repo at heygen-com/hyperframes, run the pr-to-video skill on <owner/repo#N> to produce a feature-reveal explainer MP4 read through the gh CLI. Verify that every claim in the video matches the pull request title, description, or diff.

  • Find the exact moment of a sound in a long recording

    Locate the best matching moments inside a long file and get sample trims for each.

    View prompt
    Use the earshot repo at <repo path>. Run `earshot find <file> "<description>" --top 4` and return each moment as start and end seconds with its strength. Verify that each returned interval lies inside the file length before you trim.

  • Keep an agent working when one quota runs out

    Group two models from different subscriptions so the agent moves to the other one when a quota runs out.

    View prompt
    Using the yetone/magpie repository, create a routing group named <group-name> with models=<provider/model>,<provider/model> and routing=smart, then run `magpie claude group/<group-slug>`. Report the group definition and confirm the Routing view shows a decision for one test request.

  • Map how a website's front end works

    Let your agent watch a site in a browser and explain how its scripts and network requests drive a feature.

    View prompt
    Use REA to observe <website url> in a browser and summarize its page structure, scripts and network requests. Explain how <feature> works and verify every claim against an observed request.

  • List modules and IPC in an Electron app

    Run one terminal command on an extracted Electron app to get its modules, imports and IPC boundaries.

    View prompt
    Run `npx -y rea-agents@latest analyze-javascript-application /absolute/path/to/app --json` on <path to extracted Electron app>, then explain the main modules, imports and IPC boundaries. Verify each finding cites evidence from the report.

  • Compare recursion budgets on WorkBuddy-Bench code tasks

    Run parallel and sequential refinement on the WorkBuddy code subset to see which recursion style helps more.

    View prompt
    In the google-research/harness2 repo, install WorkBuddy-Bench with harness2-setup wb, then run the code subset in parallel and sequential mode with --k 2, using a separate HARNESS2_RUNS_DIR for each. Report the judged score for each mode and which one scored higher. Verify that both runs used the same subset, k, and seed.

  • Dictate and transcribe speech without the cloud

    Speak into a floating widget and transcribe recordings, all on your own device.

    View prompt
    In the VoiceStudio repo (github.com/debpalash/VoiceStudio), set up dictation with the floating widget and transcribe <path to audio file>. Expected output: a text transcript of the audio. Verify that the transcript matches the spoken words in the recording.

  • Build a figure with a WebGL fire or water effect

    Make an isometric explainer where a shader shows fire, water or light inside the drawing.

    View prompt
    Using the skill in wheresryan22/anatomy, build a figure of <apparatus> with a WebGL shader for <effect>. Expected output: an HTML file where the shader is inside the isometric camera. Verify that the SVG still renders with WebGL turned off.

  • Turn a 3D model into game sprite frames

    Render a GLB 3D model into sprite frames from a game-style camera for a 2D or isometric mod.

    View prompt
    In the universal-modder repo, use the asset-pipeline skill to render the GLB at <model path> into sprite frames with `um render3d` using the <camera mode> mode. Verify that the output folder has one frame per heading and that the frames have transparent backgrounds.

  • Design an enclosure whose height updates from Parameters

    Model a case in the desktop app, then change one parameter and watch the design rebuild.

    View prompt
    Using SolidCraft from the tangency-labs/solidcraft repo, create an enclosure for <board or part> with a named height parameter. Expected output: a shelled design with a height parameter in Parameters. Verify by changing the height and confirming the model rebuilds.

  • Run a scripted audit in CI with explicit flags

    Add a fully scriptable iFixAi run to a pipeline using explicit flags and no interactive wizard.

    View prompt
    Use the iFixAi repo at ifixai-ai/iFixAi to add a CI step that audits <agent provider>. Use explicit flags with no wizard, run the mock smoke test first, then the real run. Verify that the smoke test output shows a failing scorecard for B01 and P01, which is expected from the bundled default fixture.

  • Check on and steer agents from your phone

    Get notified when an agent finishes and send follow-up prompts from iOS or Android.

    View prompt
    Using the stablyai/orca mobile companion, check the agent running in <worktree-name> and send the follow-up message <message>. Output the agent's latest status. Verify that the status shown on the phone matches the desktop app.

  • Redraw old Mermaid or draw.io diagrams

    Convert an existing Mermaid, draw.io or Excalidraw diagram into a styled HTML file.

    View prompt
    Using the diagram-design skill from cathrynlavery/diagram-design, redraw the existing diagram at <path to Mermaid, draw.io or Excalidraw file> as one self-contained .html file with inline SVG. Verify that every node and connection from the original appears in the output.

  • Move repository state into SQLite or PostgreSQL and object storage

    Add a graft storage section, import in shadow mode, then switch to authoritative.

    View prompt
    In the repository git-ai, read doc/graft/STORAGE.md and list the storage modes and the supported database and object storage backends. Start the server with `_build/bin/gitaly serve config.toml` using your storage section, and confirm the server runs in shadow mode before any switch.

  • Add captions to a talking-head video without touching footage

    Overlay captions on an existing talking-head video using the embedded-captions skill.

    View prompt
    Using the hyperframes repo at heygen-com/hyperframes, apply the embedded-captions skill to <video path> with the verbatim rail style and output a captioned MP4. Verify that the original footage is unchanged apart from the caption overlay.

  • Check a launch film's sound and sync with an agent

    Score a launch video's sound, find where it misses, and get timestamped fixes.

    View prompt
    Use the earshot repo at <repo path>. Run `earshot critique <film.mp4>` and `earshot sheet <film.mp4> -o sheet.png`, then list the top fixes with their timestamps and the verdict. Verify that each fix time falls inside the film duration before you edit the render code.

  • See what is left on every AI plan in one command

    Use Magpie quota to list remaining balances and quota windows for all keys and accounts.

    View prompt
    Using the yetone/magpie repository, install magpie and run `magpie quota`. Report the remaining balance or quota window for each configured key and account, and flag any entry with no data.

  • Pull apart a game's WASM web build

    Have your agent decode a game's .wasm file and explain its sections, imports and exports.

    View prompt
    Use REA to inspect the WASM artifact at <path to .wasm>, decode its sections and import and export forms, and explain what stands out. Verify against the decoded output and flag any guesses.

  • Get readable pseudocode from a native binary

    Use Hopper, Ghidra or IDA through your agent to see what one routine in a compiled program does.

    View prompt
    Use REA with my installed <Hopper, Ghidra or IDA> to analyze the binary at <path>, explain what <function or behavior> does, and show the pseudocode and references. Verify claims against the shown output.

  • Let a coding agent run voice jobs through the local API

    Have Claude Code, Codex or Cursor call Voice Studio's local API or MCP to generate audio.

    View prompt
    Install the VoiceStudio Electron app from github.com/debpalash/VoiceStudio following docs/install/agent.md, then use its local API or MCP to generate speech for <text> with the <voice name> voice. Expected output: an audio file at <output path>. Verify the file plays and the spoken words match the input text.

  • Generate a React component of a figure for a docs site

    Create a React or Next.js component version of an explainer figure for a documentation site.

    View prompt
    Using the skill in wheresryan22/anatomy, create a React component of <concept> for a Next.js docs page, with a static HTML preview. Expected output: one component file and one HTML preview. Verify that the component imports cleanly into your existing project before committing it.

  • Record a mod showcase video from the game window

    Capture the game window with its own audio, pick the best moments and cut a styled video.

    View prompt
    In the universal-modder repo, use the showcase-video skill to record the window of <game name> while the mod runs, with only the game's audio, then cut a video from an EDL. Verify that the output video plays and contains the mod's changes.

  • Get a citable grade from a second-vendor judge

    Grade your agent with a judge from a different vendor so the result can be cited.

    View prompt
    Use the iFixAi repo at ifixai-ai/iFixAi to produce a citable grade for <agent provider> using a judge from a different vendor and my fixture at <fixture path>. Verify in the report that the judge provider differs from the agent provider and that the run is not flagged as self-judged before you report the grade.

  • Run coding agents on a remote machine over SSH

    Use Orca's SSH worktrees to run agents, terminals, and file edits on a larger remote box.

    View prompt
    In the stablyai/orca repo, create an SSH worktree on <remote-host> and start an agent there with the task <task-file>. Output the agent's final summary and the list of changed files. Verify that the changed files exist on the remote host and not on the local machine.

  • Export a finished diagram to PNG or SVG

    Save a generated diagram as a PNG or SVG file for slides, docs or a website.

    View prompt
    Using the diagram-design skill from cathrynlavery/diagram-design, export the diagram at <path to .html file> to PNG and to SVG. Verify that both files open and that text and lines are not clipped.

  • Give an agent a sparse checkout of only the paths it needs

    Use graft clone and graft sparse so an agent fetches only the paths it will edit.

    View prompt
    In the repository git-ai, run `./_build/bin/graft` and read the help for the clone and sparse commands. Create a sparse workspace for <target-path> on the running server and verify that only that path appears in the working tree.

  • Create a short motion graphic or transparent overlay

    Build a sub-10-second unnarrated motion graphic as MP4 or a transparent overlay with the motion-graphics skill.

    View prompt
    Using the hyperframes repo at heygen-com/hyperframes, use the motion-graphics skill to create an 8-second logo sting with the text <headline> as a transparent overlay. Output the file and confirm the background is transparent in the render.

  • Generate a sound effect in code and listen to it

    Render a sound from a recipe, score it by ear and iterate until it matches the references.

    View prompt
    Use the earshot repo at <repo path>. Run `earshot forge --list`, then run `earshot forge <recipe> --refs <folder> --dir <out>`. Report the chosen WAV files and the critic's notes from report.md. Verify that the output folder contains report.json and the WAV files before you use them.

  • Send any OpenAI or Anthropic tool through the Magpie gateway

    Set three base URL variables so any tool that accepts a base URL uses the Magpie gateway.

    View prompt
    Using the yetone/magpie repository, confirm the gateway is listening on 127.0.0.1:3425, export OPENAI_BASE_URL=http://127.0.0.1:3425/v1 and OPENAI_API_KEY=magpie, and run <tool-command>. Report whether the tool returns an answer and whether the request appears in magpie's usage data.

  • Share a field note so the next agent starts ahead

    Write up how a game was modded and open a pull request to the knowledge base.

    View prompt
    In the universal-modder repo, search the knowledge base for <game name>, write a field note with `um kb new` that covers the versions, route, verification and gotchas, then run `um kb check` on it. Verify that the check passes before you run `um kb pr` after the human approves.

  • Add an /ifixai-skill audit command to Cursor

    Scaffold a native audit command into Cursor with one zero-install command, then run it from the chat.

    View prompt
    Use the iFixAi repo at ifixai-ai/iFixAi to scaffold the audit skill into this Cursor project with `uvx ifixai install --agents cursor`, then run `/ifixai-skill` to audit <agent name>. Report the dry-run cost estimate before any paid call. Verify that no run started until I approved the estimate.

  • Script worktree and UI steps with the Orca CLI

    Let an agent create worktrees and drive the Orca UI through the CLI for repeatable workflows.

    View prompt
    Using the stablyai/orca CLI, create a worktree for the task <task-name> and take a snapshot of its UI. Output the snapshot summary and the worktree path. Verify that the worktree exists in git worktree list before reporting success.

  • Port an existing Remotion composition to HyperFrames HTML

    Convert a React-based Remotion composition into HyperFrames HTML with the remotion-to-hyperframes skill.

    View prompt
    Using the hyperframes repo at heygen-com/hyperframes, run the remotion-to-hyperframes skill on the Remotion source in <folder path> and output the ported HyperFrames HTML. Verify that the timing of the first and last scenes matches the original composition.