Prompt Library

Analyze code dependencies and potential impacts before modifying unfamiliar code sections. Essential for preventing breaking changes during refactoring.

Quickly locate all call sites for any method or function across your entire codebase. Invaluable when planning refactoring work.

Get clear explanations of complex code or merge requests without manual investigation. Perfect for code reviews and onboarding.

Navigate call graphs to understand how functions interconnect throughout your codebase. Reveals hidden dependencies instantly.

Catch up on long-running MRs or issues by getting a summary of key decisions, changes, and action items.

Find relevant code sections in unfamiliar projects without knowing the structure. Accelerates exploration of new codebases.

Map out class hierarchies and identify which methods are overridden. Critical for understanding object-oriented architectures.

Discover how specific patterns are implemented in your existing codebase. Learn from your team's established conventions.

Follow data as it moves through multiple components, tracking each transformation step. Essential for debugging data issues.

Understand complex database schemas, relationships, and optimization opportunities. Identify performance bottlenecks in your data model.

Visualize how different components depend on each other. Understand the blast radius of potential changes.

Decode configuration files and environment setup requirements. Speeds up onboarding and project switching.

Document how your system integrates with internal and external APIs. Prevents breaking changes in integrations.

Find similar code patterns that could be consolidated into shared utilities. Reduce maintenance burden through DRY principles.

Learn how errors are handled throughout your application. Identify inconsistencies and gaps in error handling.

Map authentication flows and permission checks across your system. Essential for security audits and debugging access issues.

Understand asynchronous code, promises, and concurrent operations. Identify potential race conditions before they cause bugs.

Catch logical errors and edge cases that syntax checkers miss. Go beyond linting to find real bugs.

Receive actionable feedback on code quality, performance, and maintainability. Elevate your team's coding standards.

Ensure code follows team conventions and style guides. Consistent enforcement without tedious manual checks.

Identify security vulnerabilities during code review. Catch SQL injection, XSS, and other risks early.

Evaluate if an MR includes adequate tests for new functionality. Identify gaps before they reach production.

Assess how proposed changes will affect system performance. Catch complexity issues and bottlenecks early.

Auto-generate comprehensive MR descriptions including what changed, testing steps, and related issues.

Identify the right reviewers based on code ownership and domain expertise. Route MRs efficiently.

Detect if changes break existing APIs, contracts, or functionality. Prevent downstream breakages.

Categorize review comments by severity—critical blockers vs nice-to-have suggestions. Focus effort effectively.

Compare implementation approaches with tradeoff analysis. Make informed decisions about performance vs maintainability.

Automatically compile release notes from merged MRs. Group changes by type: features, fixes, breaking changes.

Convert support tickets into properly formatted, labeled issues. Streamline your support-to-development workflow.

Transform large epics into manageable, well-scoped issues with clear dependencies and acceptance criteria.

Create standardized issue templates for bugs, features, and tasks. Ensure consistent issue quality.

Transform external documentation into inline code comments. Keep documentation close to the code.

Identify which documentation needs updating after code changes. Prevent documentation drift.

Improve code readability with better names, simplified logic, and clearer structure. Make code self-documenting.

Update legacy code to use current language features and best practices. Modernize without breaking functionality.

Break down complex functions into testable, maintainable components. Reduce cognitive load for future developers.

Find and safely remove unused code, deprecated methods, and commented-out blocks. Keep your codebase lean.

Improve algorithmic efficiency while maintaining correctness. Optimize hot paths for performance gains.

Identify and consolidate duplicate code into reusable components. Apply DRY principles systematically.

Define architecture, components, and integration points for new features. Start projects with solid foundations.

Create comprehensive design documents with rationale, diagrams, and success criteria. Document decisions for posterity.

Compare technologies or frameworks with structured tradeoff analysis. Make informed stack decisions.

Design safe database migrations with rollback plans. Prevent data loss and minimize downtime.

Define RESTful or GraphQL APIs with proper contracts, authentication, and error handling.

Break down work and estimate development time. Improve sprint planning accuracy.

Generate comprehensive unit tests covering happy paths, edge cases, and error conditions automatically.

Design tests for component interactions, error handling, and timeout scenarios.

Create realistic test datasets including valid records, edge cases, and boundary conditions.

Understand why tests fail, identify root causes, and determine if the code or test needs fixing.

Find untested code paths and prioritize which areas need coverage most urgently.

Diagnose CI/CD failures quickly with root cause analysis and fix suggestions.

Rapidly diagnose production incidents with systematic troubleshooting guidance.

Parse complex stack traces to identify error origins and suggest fixes.

Trace bugs from symptoms to root causes. Find where problems actually originate.

Identify race conditions in asynchronous code. Debug intermittent failures systematically.

Pinpoint performance bottlenecks through profiling analysis. Know exactly what to optimize.

Find memory leaks by analyzing object lifecycles and retention issues.

Interpret cryptic third-party library errors. Understand what you're doing wrong and how to fix it.

Triage security scan results by real risk vs false positives. Prioritize remediation effectively.

Proactive security review for injection vulnerabilities, auth flaws, and data exposure risks.

Verify code meets regulatory compliance standards: SOC2, HIPAA, PCI-DSS, GDPR.

Document security controls for auditors and stakeholders. Maintain compliance evidence.

Assess external dependencies for vulnerabilities, outdated versions, and license compliance.

Generate security-focused test cases for input validation, auth bypass, and injection attacks.

Scaffold complete applications with database schemas, API endpoints, and frontend components.

Create production-ready microservices with proper patterns, health checks, and containerization.

Apply design patterns correctly with complete implementations and usage examples.

Generate standard CRUD operations with validation, error handling, and basic tests.

Build UI components matching design specs with proper accessibility and responsiveness.

Make layouts work across all screen sizes with optimized touch targets and performance.

Add ARIA labels, keyboard navigation, and screen reader support. Meet WCAG 2.1 standards.

Document UI components with usage guidelines, props, and accessibility notes.

Parse customer logs to diagnose issues and suggest solutions. Accelerate support resolution.

Transform technical errors into user-friendly messages with clear next steps.

Create self-service troubleshooting guides with diagnostic steps and escalation criteria.

Explain technical concepts without jargon. Bridge the gap between engineering and users.

Find relevant GitLab features and documentation for your specific use case.

Discover correct API endpoints with parameters, authentication, and example requests.

Explore GitLab capabilities you might not know about. Find features that match your needs.

Migrate code between frameworks while preserving functionality and adopting modern patterns.

Internationalize applications with proper i18n, date formatting, and RTL support.

Optimize CI/CD pipelines for speed, security, and reliability. Apply GitLab best practices.

Audit codebases for compliance violations. Check data handling, access controls, and encryption.

Generate audit-ready compliance reports with evidence and remediation status.

Implement granular permissions with RBAC patterns, admin interfaces, and audit logging.

Connect applications to corporate identity providers with SAML/OIDC integration.

Automate data lifecycle management per retention policies. Maintain compliance automatically.

Implement tenant boundaries for SaaS applications. Ensure complete data separation.

Document recovery procedures with RTOs, backup strategies, and failover processes.

Optimize code for memory-constrained embedded devices. Balance performance and power consumption.

Generate hardware interface code for I2C, SPI, UART protocols with proper interrupt handling.

Think through approaches collaboratively. Get challenged on tradeoffs and edge cases you might miss.

Explain problems systematically to reveal solutions. Always-available rubber duck debugging partner.

Automate repetitive development tasks with error handling and logging. Eliminate manual toil.

Create reusable CI pipeline templates with security scanning and deployment strategies.

Coordinate multiple specialized agents for complex multi-step workflows.

Analyze performance profiles to identify bottlenecks, hot paths, and optimization priorities.

Optimize slow queries with index suggestions and query rewrites. Improve database performance.

Assess framework upgrade impact with breaking change analysis and migration planning.

Triage vulnerabilities by exploitability and business impact. Focus on real threats first.

Transform large epics into implementable issues with prioritization and dependency mapping.

Explore unfamiliar codebases conversationally. Understand architecture and key dependencies interactively.

Track debugging hypotheses and test results systematically. Structured approach to complex bugs.

Challenge architectural assumptions collaboratively. Explore failure modes and scaling concerns.

Understand design decisions and tradeoffs in MRs. Get context beyond just what changed.

Get step-by-step explanations of complex algorithms and legacy code. Learn the why behind the how.