AI workflows for software engineers. Code generation, debugging, documentation, and development automation.
Implement a QA loop for AI-generated code using Devin. This playbook combines automated code reviews with an agent-recorded video walkthrough for visual verification, ensuring high-quality merges at scale.
Turn a complex, artistic concept into a manufacturable 3D model. This workflow shows how to use AI to generate a design from a photo and then create CAD files for 3D printing, even for previously 'unmanufacturable' items.
Run browser-based QA across primary and adversarial paths, producing reproducible bugs instead of a vague test summary.
Build your own local AI hardware setup by choosing the right machines (Mac, DGX, custom PC) and connecting them with Tailscale and an AI agent like OpenClaw for automated model deployment across your network.
Turn a morning product brief into a queue of isolated builds, independent code review, working previews, and explicit merge decisions in Slack.
Implement a 24/7 security scanning system where a local AI model continuously scans your codebase for issues, and a powerful cloud model periodically reviews and validates the findings for a cost-effective solution.
Create a specialized AI agent to automatically investigate and triage bug reports from Sentry. This harness uses the Claude Agent SDK to gather evidence, identify root causes, and generate actionable engineering reports.
Set up a cloud-based 'software factory' where AI agents autonomously handle coding tasks assigned and managed through a Linear project board. This workflow turns you from a coder into an AI agent manager.
Create a repeatable, automated benchmark to evaluate AI models on tasks relevant to your work. This workflow uses Claude Code to brainstorm, refine, and generate a complete evaluation system, including a test runner and scoring backend.
Leverage an AI coding assistant like Claude Code to implement a Test-Driven Development (TDD) process. This workflow allows you to reproduce, fix, and verify bug fixes with incredible speed and accuracy.
Learn Gusto's radical approach to building a new product line in 10 weeks by ditching traditional tools like Jira and Figma, and relying on a perma-Zoom room and an AI coding assistant for rapid development.
Set up a long-running AI task in Cursor to autonomously pull error logs from Sentry and Vercel, analyze them, and generate a prioritized bug-fixing plan, including surfacing critical P0 bugs.
Use an AI model like GLM 5.2 to analyze an entire codebase, summarize its architecture and recent changes, and then generate a visual HTML report to share with your team.
setting up the cost-effective GLM 5.2 AI model in your Cursor code editor using an Open Router API key, unlocking powerful, affordable AI assistance for your coding tasks.
Automate the process of verifying and patching security bugs found by an AI agent. This workflow uses a verifier sub-agent and a patching agent to propose and test fixes, with a human expert in the final review loop.
Create an LLM-powered 'judge' to score and prioritize files in a large codebase for security analysis. This workflow helps focus expensive bug-hunting efforts on the most high-risk areas.
Create a custom AI agent that relentlessly hunts for security vulnerabilities in your codebase. This system uses a large language model with specific tools to find, test, and prove the existence of bugs.
Use a Codex Automation to create a 'meta-agent' that analyzes your codebase, identifies opportunities for new reusable agent skills, and then spawns sub-agents to automatically test and validate those new skills.
Create an AI agent in Claude Code to automatically review aging pull requests, prompt your team for action via Slack, and even fix issues autonomously. This routine helps engineering teams ship code faster and reduce manual follow-up.
Leverage powerful AI coding agents to perform deep, exhaustive benchmarking on complex infrastructure problems. This workflow automates the process of testing numerous solutions, like different database engines or index types, to find the optimal configuration without manual effort.
Use Claude as a planning guide while Claude Code and Terminal handle the technical work required to submit a Replit app to the App Store.
Turn a detailed greenfield prompt into a runnable prototype and judge the result through real interactions.
Build a new prototype in one pass, then test the working surface before making narrow follow-up changes.
Build a Bluetooth desk button that lights up when Claude needs permission, lets you approve the action physically, and celebrates successful runs. Claude Code handles the device protocol and firmware, even if hardware is new to you.
Turn one awkward section of an HTML plan into a temporary editing app. Claude builds controls for the exact data you need to change, then exports the revised rules back into your plan.
Turn a spoken feature idea into a versioned Markdown spec, then let a coding agent implement and verify it. Future changes start in the spec, which records the behavior and its history.
With a background coding agent connected to Notion, turn a short task and screenshot into a GitHub pull request, live preview, test notes, and UI verification in about 20 minutes.
Have a Notion Custom Agent assemble the daily standup pre-read from recent Slack discussion, Notion tasks, GitHub pull requests, meeting notes, and Honeycomb metrics, then post the page to your team channel.
Overcome generic AI-generated designs by building a custom prototyping environment. This workflow connects your company's design system to an AI code editor, ensuring all prototypes are on-brand and high-fidelity.
Delegate a long data migration with explicit invariants, checkpoints, validation queries, and a reversible cutover.
Turn a vulnerability report into scoped code fixes, tests, and a traceable remediation record.
Build a flaky test skill from your own failure history, let it add genuinely new fixes to its reference material, and use each solved pattern to find related tech debt across the codebase.
Create a PR skill that explains intent from the coding session, then use a hook to route every agent generated pull request through the same team standard.
Learn how Stripe's engineering team turns a simple Slack message into a complete pull request using AI agents. This workflow automates environment setup, coding, and testing, triggered by a simple emoji reaction, dramatically reducing the friction to start new development work.
Bypass the complex Azure web portal and manage user permissions in seconds. Use natural language prompts in the Warp terminal to assign multiple roles to users instantly, saving significant time on cloud administration.
Turn your repository's real preflight routine into a `/ship` skill. It checks the commit, runs the correct lint and build commands, pushes the branch, watches CI, fixes minor failures, and reports when the pull request is ready.
Compress the path from live feedback to a testable code change by capturing the user’s words, structuring the issue, creating a Linear ticket, and invoking a context-rich coding agent from Slack.
Turn raw Cursor usage data into defensible adoption cohorts, a reusable analysis, and practical coaching that helps each group try the behavior most likely to deepen its use of AI.
Build a family TV app that turns parent chosen themes into a continuous YouTube stream behind a child simple interface. Jesse and her coding agent shipped Mira to a Google TV streamer in four days.
Wrap Figma extraction, implementation, and browser comparison in one `/figma` command so a teammate can paste a frame link and get a close first pass that corrects its own obvious misses.
Pair Opus 4.6 as the eager builder with GPT-5.3 Codex as the rigorous reviewer: let one create the broad change, then let the other challenge its architecture, performance, and edge cases before shipping.
Build a local Chrome extension that turns a focused Slack link into three to five takeaways in seconds. Joe dictates the PRD, reuses a Chrome extension skill, tests in developer mode, and fixes a raw JSON response with a screenshot.
Use one model to build quickly and a second model to review the diff for plan mismatches, code smells, and better architecture before applying the fixes.
Turn a feature idea into a user flow, timing diagram, and UI mockups that your coding agent can use as the implementation plan.
Build and debug an ambitious 3D AI application by combining v0’s code generation with streaming model output, durable execution, outside technical research, and custom visual diagnostics inside the app.
Use v0 as a production branch workspace: import the real repository, build a bounded feature with production constraints, iterate against the running app, and hand engineers a reviewable PR and preview.
Use an agent stop hook to run project-specific checks when files change, feed actionable failures back into the same session, and finish only when the bounded validation loop passes.
Turn repeated AI commands into safe shell aliases, then promote a stable multi-step prompt into a small CLI with explicit inputs, visible configuration, and reproducible output.
Compress a codebase’s architecture into source-grounded Mermaid diagrams, store them beside the repository, and load only the relevant diagrams into an AI coding session.
Use a reusable Plans.md rubric to make Codex produce a self-contained, milestone based implementation plan for a complex change. Alex plans a Python SDK from an existing TypeScript SDK before asking Codex to build it.
Give parallel Codex tasks separate Git worktrees so each agent has its own branch and directory. Alex creates French and German variants, runs both at once, and keeps their changes independently testable.
Open an unfamiliar repository in Codex, ask how to run it, launch the app with the returned command, and make a small behavior change in plain language while Codex traces the relevant code.
Hand a small internal-tool annoyance to an AI coding agent, then turn its focused fix into a pull request without pulling an engineer away from larger work.
Shape a small product improvement in v0, hand the refined specification to Devin, and use the working preview to finish the feature quickly.
Speedrun a small multiplayer flight prototype by fixing the minimum scene and control contract, getting one local player working, adding an authoritative WebSocket loop in a separate workstream, and testing synchronization and failure behavior before adding polish.
Build a 3D game as a sequence of playable slices, asking the coding assistant to explain unfamiliar graphics and networking choices, measuring each new behavior, and returning to a clean checkpoint when layered fixes obscure the coordinate or state model.
Build a deliberate code analysis packet by selecting the smallest sufficient set of repository files, stating the question and constraints, and giving a reasoning model exact paths and contents without hidden context or irrelevant generated code.
Extend Cursor with one narrowly scoped MCP at a time, inspect the tools it exposes, and test read only browser or external actions in a sandbox before allowing the agent to touch authenticated sessions, databases, or mutable systems.
Build a version controlled localization service that extracts changed source strings, translates them with a language specific glossary and style prompt, validates placeholders and structure, and routes uncertain copy to native language review.
Give Replit Agent a complete product blueprint, build the app in working slices, and steer each feature with real role, integration, and production tests.
Keep AI prototypes easy to explore and recover by naming a stable baseline, creating a fork for each direction, and separating diagnosis from implementation when a change fails.
Capture a noisy test run, have Claude group warnings by type and worst offending files, save the result as a tiered migration checklist, and let Cursor or Devin take the next bounded task whenever capacity opens.
Move engineering guidance into the repository, keep full human documentation under docs, and create concise central agent rules that link to it. Tool specific files then point to one source instead of duplicating instructions.
Build a narrow email MCP by proving the provider call in a small script, wrapping it in a validated tool contract, and testing the enabled tool with safe recipients before connecting it to a larger agent workflow.
Break a mobile feasibility deadlock by building the smallest functional prototype of the disputed capability, run it on a real phone, and use the result to replace abstract arguments with concrete technical and product questions.
Connect incident alerts to a read only Devin investigation so the on call engineer arrives to a timestamped evidence packet, likely code path, and explicit unknowns instead of a cold page.
Hand Devin a tightly scoped interface problem with the route, state, viewport, screenshot, and acceptance criteria it needs, then use before and after evidence plus browser checks to iterate quickly without losing responsive or accessible behavior.
Use DeepWiki to locate the code and conventions behind a small integration, turn that context into a bounded Devin task, and let the agent work asynchronously toward a reviewable pull request.
Build a multi-device fitness app by proving the smallest voice-to-structured-data loop first, then use Cursor for scoped planning and implementation while Xcode, physical devices, version control, and privacy constraints provide the feedback the agent cannot infer.
Give Cursor reliable feedback loops before asking it to repair code: establish types, linting, formatting, and focused tests, let the agent reproduce a failure, then inspect the diff and rerun the same checks plus a reusable branch review.
Debug an AI product from observed behavior instead of vibes: sample real traces, annotate the earliest meaningful failure, count a grounded error taxonomy, and build narrow evals that can tell whether a change fixed the problem without creating a regression.
Package a local Claude skill for the web app without carrying private files with it, fix the naming and archive structure, upload it to the intended workspace, and test it with synthetic input.
Use Claude Code inside a local skills repository to generate a task-specific skill, inspect and validate the files it creates, then test the skill on representative input and improve the reusable instructions.
Build a small meta-skill that creates other Claude skills consistently: ground it in the current format, keep the folder lean, validate the structure, and test whether it produces a useful second skill.
Create a small local Next.js project from an empty folder with Cursor, learn how to run and inspect it, and save a private version-controlled baseline before adding real features.
Build a small event hub that centralizes guests, dishes, recipes, and photos, then personalize it with intentional typography and art while making dietary information clear and usable.
Join 100,000+ product managers who use ChatPRD to write better docs, align teams faster, and build products users love.