AI-assisted coding tools, agents, and workflow guides for developers.
Intermediate
Restructure your dev loop around AI: spec, prompt, review, ship, with humans as reviewers.
Intermediate
Write acceptance criteria before prompting AI; treat the spec as a contract.
Beginner
.cursorrules, CLAUDE.md, .clinerules, copilot-instructions — what each does and how to share.
Intermediate
Break long agent runs into committed checkpoints you can bisect and revert.
Intermediate
Decide what humans must approve vs delegate: risk tiers and approval points.
Intermediate
Repeatable patterns for prompts that produce consistent, reviewable code: role, context, constraints, output format.
Intermediate
Set the agent's role, tone, and hard rules via a system prompt that anchors every turn.
Intermediate
Pick the right model/context size per task and stay under the limit with chunking.
Intermediate
Anchor output shape with one or two input/output pairs before the real task.
Advanced
Ask the model to reason step-by-step before writing code on tricky logic.
Beginner
Patterns for 'write X' prompts: signature first, then body, then tests.
Intermediate
Feed errors with full context and ask for a hypothesis before a fix.
Intermediate
Preserve behavior: state invariants, ask for a plan, gate with existing tests.
Intermediate
Generate useful tests: cover happy path, edge cases, and failure modes — not just the obvious.
Beginner
Master Cursor's AI-native features for faster, higher-quality coding.
Intermediate
Tune Cursor output quality with project rules, ignore patterns, and context scoping.
Beginner
Get fast, relevant completions by tuning Cursor's tab model, accept behavior, and context.
Intermediate
Use @-mentions, @codebase, and folders to give Cursor chat the right context.
Advanced
Multi-step agentic edits in Cursor with a plan, terminal access, and per-step review.
Intermediate
Terminal-native AI coding with agentic capabilities for complex, multi-file tasks.
Advanced
Drive safe large-scale refactors with Claude Code: scope, plan, checkpoint, verify.
Intermediate
Persist project conventions and session notes with CLAUDE.md memory files.
Advanced
Spawn specialized subagents for planning, coding, and reviewing within one session.
Advanced
Register local and remote MCP servers with Claude Code for custom tools.
Advanced
Expose custom tools and resources to AI clients via the Model Context Protocol.
Advanced
End-to-end MCP server: tools, resources, prompts, error handling, and client registration.
Advanced
Expose read-only resources and reusable prompt templates beyond tools.
Advanced
Host MCP servers over HTTP/SSE for team-shared, always-on tool access.
Advanced
Coordinate multiple AI agents (planner, coder, reviewer) for tasks too big for one context.
Beginner
What 'agent' means for coding: tool use, multi-step loops, and human-in-the-loop gates.
Intermediate
Keep multi-file AI edits safe: scope, plan, per-file review, and a single gate.
Intermediate
Keep AI context focused: what to include, what to drop, and when to compact.
Advanced
Persistent project memory: rules files, memory docs, and vector recall.
Intermediate
Ask the agent for a plan first, review it, then execute — cheap insurance for big tasks.
Advanced
Use an AI reviewer agent to gate the coder: concrete reject criteria and a tight loop.
Intermediate
Wire AI review into CI/PR pipelines: triggers, prompts, gating, and human fallback.
Advanced
Run AI generation in CI for deterministic outputs: typed clients, schema types, fixtures.
Intermediate
Run a fast AI pass in a pre-commit hook: fix typos, add missing types, format.
Advanced
Wire an AI reviewer into PR checks with concrete, checkable criteria.
Beginner
Use GitHub Copilot's inline completions, Chat, and Edits effectively in VS Code and JetBrains.
Intermediate
Open-source autonomous coding agent in VS Code with diff review and terminal access.
Intermediate
Git-native AI pair programmer that edits files and commits with you in the terminal.
Intermediate
Self-hostable VS Code/JetBrains extension with configurable models, context providers, and tools.
Intermediate
AI assistant with deep codebase search and context over large monorepos.
Beginner
Line and block completions with a private/local model option for regulated environments.
Beginner
Fast inline completions and chat with a generous free tier and broad IDE support.
Intermediate
AWS-native AI assistant with security scans, AWS code suggestions, and reference tracking.
Beginner
In-browser AI on Replit: generate, explain, and run code without local setup.
Intermediate
AI-native IDE from Codeium with Cascade, a multi-step agent that edits across files.
Beginner
Generate a function from a signature + doc + examples; gate with types and tests.
Intermediate
Generate a class from responsibilities + invariants; prefer composition over inheritance.
Intermediate
Scaffold a full CRUD route (handler, validation, types, tests) from a resource spec.
Intermediate
Use AI to replace repetitive boilerplate with helpers, generics, or codegen.
Intermediate
Generate and explain regex from intent + test pairs; never ship unexplained regex.
Advanced
Generate SQL from a natural-language intent + schema; explain and test it.
Beginner
Generate code from templates with placeholders for repeatable structures.
Intermediate
Diagnose errors by feeding the message, stack, and relevant code; ask for root cause first.
Intermediate
Walk the stack with AI: identify the entry point, the bad state, and the fix site.
Intermediate
Get a minimal, targeted fix — not a rewrite — by constraining the AI to the root cause.
Intermediate
Decide whether the test or the code is wrong, then fix the right side.
Advanced
Diagnose slow code with a profile + the hot function; ask for an algorithmic fix.
Advanced
Fix security issues with AI + a security tool's finding; verify with the tool.
Intermediate
Fix breakages after a dependency or platform upgrade with AI + the changelog.
Beginner
Generate unit tests covering happy path, edges, and failures with strong assertions.
Intermediate
Generate integration tests that exercise real modules together with a test DB.
Advanced
Generate end-to-end tests (Playwright/Cypress) for critical user flows.
Intermediate
Use coverage to find untested branches; AI writes targeted tests for each.
Intermediate
Use AI to review diffs for bugs, smells, and missing tests before human review.
Advanced
Review diffs for security issues: injection, auth, secrets, path traversal.
Intermediate
Generate user-facing docs from code + intent; keep them in sync via a regen check.
Beginner
Generate doc comments for non-obvious functions; skip trivial ones and avoid noise.
Intermediate
Generate a README from the repo's actual commands, structure, and conventions.
Intermediate
Generate API docs from the OpenAPI spec or route handlers + zod schemas.
Advanced
Generate an architecture doc (diagram + data flow + decisions) from the codebase.
Advanced
Plan a big refactor as ordered, behavior-preserving steps; gate each with tests.
Advanced
Migrate code across frameworks/languages with a mapping table + per-file verification.
Intermediate
Upgrade deps with AI: read the changelog, fix breakages, verify with tests.
Templates
Next Step
Testing, security, performance and accessibility assurance before shipping.