prompts
Ready-made prompts, templates, and shortcuts for your workflow.
New to Agentic Coding
Ask a Question About This Code
Ask Claude to explain what selected code does.
Find a File
Ask Claude to locate a file by name or purpose.
Search the Codebase
Find where something is used or defined.
Make a Small Edit
Change a single line or value in a file.
Undo Last Change
Revert the most recent edit Claude made.
Run This Project
Figure out how to start the dev server or run the app.
Install Dependencies
Install packages and resolve missing dependencies.
What Does This Error Mean
Explain an error message in plain language.
Fix a Typo
Find and fix a spelling mistake or typo in code.
Read and Summarize a File
Get a quick overview of any file.
What Language Is This
Identify the language, framework, and stack.
Help Me Understand This Concept
Explain a programming concept using examples from this codebase.
Where Do I Start
Get oriented in an unfamiliar codebase.
Check If This Works
Verify code runs without errors.
Add a Comment
Add a helpful comment explaining tricky code.
Show Project Structure
Map out the file and folder layout.
What Changed Recently
Summarize recent git changes.
How to Use This Function
Show usage examples for a function or component.
Break This Down for Me
Simplify complex code into plain steps.
Save My Work
Stage and commit current changes with a good message.
Git
Commit and Push Changes
Stage all changes, create a commit with a descriptive message, and push to the current branch.
Create a Feature Branch
Create and check out a new feature branch from the current base.
Stash, Pull, and Rebase
Safely stash your changes, pull the latest, rebase, and restore your work.
Create a Pull Request
Push the current branch and open a pull request with a summary of changes.
Write PR Description
Generate a clear pull request title and description from the current diff.
Address PR Review Comments
Read reviewer feedback on a PR and implement the requested changes.
Resolve Merge Conflicts
Resolve all git merge conflicts, preserving the intended changes from both sides.
Squash Commits
Combine multiple small commits into one clean commit with a good message.
Summarize Git Status
Show a clear summary of what's changed, staged, and ready to commit.
Cherry-Pick a Commit
Apply a specific commit from another branch.
Undo a Commit
Revert the last commit while keeping changes staged.
Bisect to Find a Bug
Use git bisect to find which commit introduced a bug.
Clean Up Branches
Delete merged and stale local branches.
Rebase and Clean History
Rebase and clean up commit history before merging.
Git Status
Show which files are modified, staged, or untracked.
Compact Commit History
Show the last 20 commits in a compact one-line format.
Visual Branch History
Show a visual graph of all branches and their commits.
List Local Branches
Show all local branches and highlight the current one.
List All Branches
Show all branches including remote tracking branches.
Show Unstaged Changes
Display line-by-line changes that haven't been staged yet.
Show Staged Changes
Display changes that are staged and ready to commit.
Change Summary
Show a summary of which files changed and how many lines were added or removed.
List Stashes
Show all stashed changes you've saved for later.
Show Remote URLs
List all configured remotes with their fetch and push URLs.
Commits This Week
Show all commits made in the last 7 days.
Contributors by Commit Count
Rank contributors by number of commits.
Fetch All Remotes
Download latest changes from all remotes without merging.
Stage All Changes
Stage every modified and new file for the next commit.
Push to Remote
Upload local commits to the remote repository.
Setup
Set Up React Navigation
Add React Navigation with stack, tab, or drawer navigators.
Set Up Git Worktrees
Create a git worktree so you can work on multiple branches in parallel without stashing.
Scaffold a React Component
Generate a new React component with TypeScript, props interface, and a basic test file.
Set Up a Pinia Store
Create a Pinia store with typed state, getters, and actions.
Configure Expo Project
Set up or update Expo configuration for a managed workflow project.
Scaffold an API Endpoint
Generate a new API route with request validation, error handling, and a test.
Initialize a New Project
Set up a new project with the right structure, config files, and dependencies.
Integrate a Native Module
Add and configure a native module or library with platform linking.
Set Up Environment Variables
Create or update .env files with the required configuration for this project.
Go Project Structure
Organize a Go project with cmd/, internal/, and pkg/ layout.
Go Module Management
Clean up go.mod, tidy dependencies, and resolve version conflicts.
Python Virtual Environment Setup
Set up a Python virtual environment with proper dependency isolation.
Set Up a Monorepo
Configure a monorepo with workspaces, shared dependencies, and build orchestration.
Python Dependency Management
Set up or migrate dependency management with pip, poetry, or uv.
Set Up Authentication
Add user authentication with sign up, sign in, sessions, and protected routes.
Python Project Structure
Organize a Python project with clean module layout and conventions.
Set Up Push Notifications
Configure push notification handling for iOS and Android.
Set Up Testing Framework
Add a test runner and write the first test.
Add SwiftUI Previews
Set up comprehensive SwiftUI previews with sample data and multiple configurations.
Add Nuxt Route Middleware
Create route middleware for auth guards or redirects.
Python Linting and Formatting
Set up ruff, black, or isort for consistent code formatting.
Configure Deep Linking
Set up URL-based deep linking and universal links.
Set Up a Database
Configure a database connection and initial schema.
Set Up SwiftData Models
Define SwiftData models with relationships, queries, and migration support.
Create a Nuxt Plugin
Register a Nuxt plugin for global utilities or third-party integrations.
Set Up CI Pipeline
Add continuous integration with tests and linting.
Set Up ESLint and Prettier
Configure ESLint and Prettier with sensible defaults.
Set Up Docker for Development
Create a Docker development environment with hot reload.
Configure Swift Package
Set up or fix Swift Package Manager configuration with proper targets and dependencies.
Configure SvelteKit Adapter
Set up the right SvelteKit deployment adapter for your hosting target.
Go Linting Setup
Configure golangci-lint with appropriate linters for the project.
Go Configuration Management
Load configuration from environment variables and config files.
Configure Splash Screen and App Icon
Set up the splash screen and generate app icons for all device sizes.
Set Up @AppStorage and Defaults
Configure UserDefaults-backed preferences with @AppStorage and a settings model.
Configure macOS Windows
Set up WindowGroup, window sizing, and multi-window management for macOS apps.
Build Menu Bar App
Set up a macOS menu bar app with MenuBarExtra and system integration.
Fix Code Signing and Notarization
Configure code signing, entitlements, and notarization for distribution.
Planning
Plan a Feature
Design the architecture and implementation plan before writing any code.
Clarify Requirements
Ask smart questions to understand ambiguous requirements before starting.
Find All TODOs and FIXMEs
List all TODO, FIXME, HACK, and XXX comments across the codebase.
What Should I Work On Next
Analyze the project state and suggest the highest-impact thing to work on.
Write a Technical Spec
Draft a technical specification document for a feature or system change.
Estimate Implementation Effort
Break a task into subtasks and estimate complexity for each.
Break Into Tasks
Split a large feature into small, shippable tasks.
Compare Approaches
Evaluate two or more ways to implement something.
Write Acceptance Criteria
Define clear done criteria for a feature.
Code Review
Security Review
Scan the current file or project for common security vulnerabilities.
Code Quality Review
Review code for bugs, readability, and adherence to project conventions.
Refactor This Code
Simplify and improve code structure without changing behavior.
Performance Audit
Identify performance bottlenecks — slow queries, unnecessary re-renders, heavy computations.
Accessibility Audit
Scan UI code for WCAG compliance issues — missing labels, poor contrast, keyboard traps.
Clean Up AI-Generated Code
Remove unnecessary abstractions, verbose comments, and over-engineering from AI-generated code.
Check Type Safety
Find type issues — any casts, missing generics, loose types that could cause runtime errors.
Audit Dependencies
Check for outdated, vulnerable, or unnecessary dependencies.
Review Naming Conventions
Check that names are clear, consistent, and follow conventions.
Review Error Handling
Check that errors are caught and handled properly.
Check for Edge Cases
Find inputs or scenarios the code doesn't handle.
Improve Readability
Make code easier to read and follow.
Refactor
Go Error Handling Patterns
Apply idiomatic Go error handling with wrapping, errors.Is, and errors.As.
Simplify This Code
Reduce complexity — fewer lines, clearer logic, same result.
Simplify SwiftUI View Body
Break down complex SwiftUI views into smaller, reusable subviews.
Extract a Vue Composable
Extract reusable logic into a Vue composable function.
Extract Into Components
Break a large file into smaller, focused, reusable components.
Go Interface Design
Design small, focused interfaces following Go conventions.
Go Goroutine Safety
Audit and fix concurrency issues with mutexes, channels, and sync primitives.
Modernize Legacy Code
Update legacy patterns to modern language and framework idioms.
Migrate to Swift Observation
Migrate from ObservableObject/Combine to the Swift Observation framework (@Observable).
Convert to Script Setup
Refactor a component to use the <script setup> syntax.
Remove Duplicate Code
Find repeated code patterns and extract them into shared functions or modules.
Fix SwiftUI Navigation
Restructure navigation to use NavigationStack with typed paths or NavigationSplitView.
Clean Up Imports
Remove unused imports, sort them, and organize by convention.
Use Nuxt Auto-Imports
Replace manual imports with Nuxt's auto-import conventions.
Add Error Handling
Add proper error handling, try/catch blocks, and graceful failure paths.
Rename for Clarity
Improve variable, function, and file names to be more descriptive and consistent.
Extract Protocol Interfaces
Refactor concrete types into protocol-oriented designs for testability and flexibility.
Go Context Propagation
Thread context.Context through call chains for cancellation and deadlines.
Split a Large File
Break a large file into smaller, focused modules.
Convert to TypeScript
Convert a JavaScript file to TypeScript with proper types.
Replace Callbacks with Async/Await
Modernize callback-based code to use async/await.
Structure MVVM Architecture
Organize SwiftUI code into a clean Model-View-ViewModel architecture.
Consolidate Constants
Gather scattered magic numbers and strings into a constants file.
Go Dependency Injection
Wire dependencies through constructors without a DI framework.
Improve Function Signatures
Simplify functions that take too many parameters.
Go Worker Pool
Implement a worker pool pattern for bounded concurrent processing.
Improve Swift Generics
Refactor repetitive code into generic types with proper constraints and associated types.
Go Generics Patterns
Apply Go generics to reduce duplication with type-safe abstractions.
Testing
Write Tests for This Code
Generate unit tests covering the main paths, edge cases, and error conditions.
Fix Failing Tests
Diagnose and fix the currently failing tests.
Write Integration Tests
Generate integration tests for API endpoints or multi-component user flows.
Add Test Coverage
Identify untested code paths and write tests to cover them.
Pytest Patterns and Fixtures
Write pytest tests with fixtures, parametrize, and proper assertions.
Generate Test Data
Create realistic mock data, fixtures, and factories for testing.
Test Edge Cases
Identify and write tests for edge cases, boundary conditions, and unexpected inputs.
Go Table-Driven Tests
Write table-driven tests with subtests and clear assertions.
Write a Unit Test
Write a focused unit test for a single function.
Mock an External Service
Create mocks for API calls or external dependencies.
Test Error Paths
Write tests for error handling and failure scenarios.
Add Snapshot Test
Create a snapshot test for UI components.
Write an End-to-End Test
Write a browser-based end-to-end test for a user flow.
Write Svelte Component Tests
Write tests for Svelte components using Vitest and Testing Library.
Test an API Endpoint
Write integration tests for an API endpoint.
Write Vue Component Tests
Write unit tests for a Vue component using Vitest and Vue Test Utils.
Add Swift Tests
Write tests using Swift Testing framework with @Test, #expect, and parameterized cases.
Add Mobile Tests
Write unit or integration tests for React Native components.
Debug
Diagnose This Error
Trace an error back to its root cause and suggest a fix.
Check Application Logs
Read recent logs and surface errors, warnings, or unusual patterns.
Fix SwiftUI State Management
Audit and fix misuse of @State, @Binding, @StateObject, @ObservedObject, and @EnvironmentObject.
Fix This Bug
Identify the root cause of a bug, explain it clearly, and apply the smallest safe fix.
Fix Lint and Formatting Issues
Run the linter and auto-fix all linting and formatting issues in the project.
Fix Vue Reactivity Issues
Identify and fix common Vue reactivity pitfalls.
Fix Build and Compile Errors
Find and fix all current build, compile, or type errors so the project builds clean.
Python Type Hints and Mypy
Add type annotations and fix mypy errors across the codebase.
Fix Swift Concurrency
Audit async/await usage, actor isolation, and Sendable conformance.
Fix Flaky Test
Investigate and stabilize an intermittently failing test.
Python Exception Handling
Implement proper exception handling with custom errors and error responses.
Improve Error Handling
Add proper Swift error handling with typed errors, do/catch, and Result.
Find Memory Leak
Identify potential memory leaks — unclosed connections, listeners, growing caches.
Trace Data Flow
Follow data from input to output through the system, showing every transformation.
Debug a Network Request
Trace and fix a failing HTTP request.
Debug a State Issue
Track down a state management bug.
Debug a Build Failure
Fix a failing build or CI pipeline.
Debug React Native App
Set up debugging tools and diagnose common React Native issues.
Debug a Race Condition
Find and fix timing-dependent bugs.
Fix Combine Pipelines
Audit and fix Combine publisher chains for correctness, memory, and threading.
Explain
Explain This File
Walk through what a file does, its role in the project, and key decisions.
Explain This Codebase
Give a high-level overview of the project architecture, key directories, and how things connect.
Explain This Error
Break down an error message and what caused it.
Explain This Regex
Translate a regular expression into plain English.
Explain the Architecture
Describe the high-level architecture and how pieces connect.
Explain Recent Git History
Summarize what happened in recent commits.
Explain This Dependency
What does this package do and why is it here.
Explain This Config File
Walk through what each setting in a config file does.
Docs
Add Docstrings and JSDoc
Add documentation comments to functions, classes, and modules.
Generate a README
Create a README.md with setup instructions, usage, and project overview.
Onboard a New Developer
Generate a getting-started guide for someone new to this codebase.
Generate API Documentation
Document all API endpoints with methods, parameters, responses, and examples.
Add Inline Comments
Add comments to explain non-obvious logic, complex algorithms, and business rules.
Write Changelog Entry
Summarize recent changes into a clear changelog entry.
Write a Contributing Guide
Create a CONTRIBUTING.md with setup and contribution guidelines.
Document Environment Variables
Create a reference for all required environment variables.
Write Architecture Documentation
Document the system architecture and key design decisions.
Write a Runbook
Create operational runbook for common issues.
Frontend
Add Responsive Design
Make a page or component work well on mobile, tablet, and desktop.
Fix Reactive Declarations
Find and fix broken or inefficient reactive declarations in Svelte components.
Improve Accessibility
Fix accessibility issues — add ARIA labels, keyboard navigation, and screen reader support.
Add Platform-Specific Code
Handle iOS and Android differences with platform-specific logic.
Migrate to Svelte 5 Runes
Convert legacy Svelte reactivity to Svelte 5 runes ($state, $derived, $effect, $props).
Optimize Bundle Size
Analyze and reduce the JavaScript/CSS bundle size.
Create Svelte Stores
Set up Svelte stores for shared state with proper typing and subscriptions.
Add Loading States
Add loading spinners, skeletons, and error states for async operations.
Write SvelteKit Load Functions
Create type-safe SvelteKit load functions for page data fetching.
Add Form Validation
Add client-side form validation with clear error messages.
React Native Responsive Styling
Add responsive StyleSheet patterns that adapt to different screen sizes.
Add SvelteKit Form Actions
Implement SvelteKit form actions with validation and progressive enhancement.
Add Dark Mode
Add dark mode support with a toggle and system preference detection.
Reduce Re-renders
Find and fix unnecessary re-renders in React components.
Add Gesture Handling
Implement touch gestures like swipe, pinch, or pan using gesture handlers.
Set Up SvelteKit Routing
Create SvelteKit routes with layouts, params, and route groups.
Design a Vue Component API
Design a component with clear props, emits, and slot interfaces.
Add Lazy Loading
Lazy load images, components, and routes to improve initial page load.
Improve Component Composition
Refactor Svelte components using slots, snippets, or render delegation.
Add Vue Transitions
Add enter/leave transitions to Vue components.
Add an Animation
Add a smooth CSS or JS animation to a UI element.
Add Svelte Transitions
Add smooth transitions and animations to Svelte component state changes.
Add an Error Boundary
Add graceful error handling to UI components.
Add a Skeleton Loader
Replace loading spinners with skeleton placeholder UI.
AppKit and SwiftUI Interop
Bridge between AppKit and SwiftUI using NSViewRepresentable and hosting controllers.
Configure SSR and CSR
Set the right rendering strategy for SvelteKit pages and components.
Add VueUse Composable
Integrate a VueUse utility composable to avoid reinventing the wheel.
Add Keyboard Navigation
Make a UI component fully navigable with the keyboard.
Add Local Data Persistence
Persist data locally using AsyncStorage or MMKV.
Add Toast Notifications
Add a toast notification system for user feedback.
Add SEO Meta with useHead
Set up page-level SEO meta tags using Nuxt's useHead.
Add React Native Animation
Add smooth native-thread animations using Reanimated or Animated API.
Add Search and Filter
Add search and filtering to a list or table.
Fix Svelte Accessibility
Find and fix accessibility issues flagged by Svelte's built-in a11y warnings.
Fix SwiftUI Accessibility
Add accessibility labels, traits, and VoiceOver support to SwiftUI views.
Add Vue Error Handling
Set up error boundaries using onErrorCaptured in Vue.
Add Internationalization
Set up multi-language support for the app.
Handle App Permissions
Request and manage runtime permissions for camera, location, etc.
Add SvelteKit SEO
Add meta tags, Open Graph, and structured data to SvelteKit pages.
Add SwiftUI Animations
Add smooth animations and transitions to SwiftUI views.
Use Provide/Inject
Share state down the component tree without prop drilling.
Add a Modal Dialog
Create an accessible modal component.
Use Svelte Context API
Share data between parent and child components using setContext/getContext.
Build a Vue Form
Create a form with v-model bindings, validation, and submission.
Fetch Data with useFetch
Use Nuxt's useFetch or useAsyncData for SSR-friendly data loading.
Fix Scoped Styles
Organize and fix scoped CSS in Svelte components.
Add Offline-First Support
Make the app work reliably without network connectivity.
Backend
Add SvelteKit Hooks
Implement SvelteKit hooks for auth, logging, or request transformation.
Create SvelteKit API Route
Build a SvelteKit API endpoint with proper methods and error handling.
Add SvelteKit Route Guards
Protect SvelteKit routes with auth checks and redirects.
API
Design an API
Design RESTful endpoints with routes, methods, request/response schemas, and auth.
Add Input Validation
Add request validation with proper error messages for all API inputs.
Generate OpenAPI Spec
Generate an OpenAPI/Swagger specification from existing API routes.
Add Rate Limiting
Add rate limiting to API endpoints to prevent abuse.
Go HTTP Handler
Implement a clean HTTP handler using stdlib net/http or a router.
Standardize Error Responses
Create consistent error response format across all endpoints.
Add API Versioning
Set up versioned API routes.
Add a Nuxt Server Route
Create a Nuxt server API route with validation and error handling.
Add API Authentication
Add authentication middleware to API endpoints.
Add a Webhook
Create a webhook endpoint with signature verification.
FastAPI Route Patterns
Set up FastAPI routes with path params, query params, and request bodies.
Add WebSocket Support
Add real-time communication with WebSockets.
Pydantic Model Design
Design Pydantic models with validation, serialization, and field constraints.
Add File Upload
Implement a file upload endpoint with validation.
Django Views and DRF Serializers
Create Django REST Framework views with serializers and permissions.
Go Middleware Pattern
Implement HTTP middleware for auth, logging, or request processing.
Flask Blueprint Organization
Organize Flask routes into blueprints with proper separation of concerns.
FastAPI Dependency Injection
Use FastAPI's Depends system for shared logic, auth, and database sessions.
Django Admin Customization
Customize Django admin with list displays, filters, and inline editing.
Go gRPC Service
Implement a gRPC service with protobuf definitions and server setup.
Database
Design Database Schema
Design a database schema with tables, relationships, indexes, and constraints.
Write Database Migration
Generate a database migration with up and down steps.
Optimize Database Queries
Find slow queries and optimize them with indexes, rewrites, or caching.
Django Model Design
Design Django models with proper fields, relationships, and Meta options.
Create Database Seed Data
Generate seed data scripts for development and testing.
Add Database Indexes
Identify and add missing database indexes.
SQLAlchemy ORM Patterns
Write SQLAlchemy models and queries with proper session management.
Add Soft Delete
Implement soft deletion instead of permanent record removal.
Alembic Database Migrations
Create or fix Alembic migrations for SQLAlchemy schema changes.
Add Database Transactions
Wrap related database operations in transactions.
Set Up Database Backup
Create a database backup and restore strategy.
Go Database Access
Implement database access with sqlx, pgx, or GORM.
Data
Parse a CSV File
Read and process CSV data.
Transform JSON Data
Reshape or filter a JSON structure.
Validate Data Shape
Add runtime validation for incoming data.
Add Pagination
Implement paginated data fetching and display.
Export Data to File
Export data as CSV, JSON, or other format.
Security
Scan for Vulnerabilities
Check code for common security issues like XSS, SQL injection, and auth flaws.
Add Input Sanitization
Sanitize user inputs to prevent injection attacks.
Review Authentication Flow
Audit login and session handling for security gaps.
Check for Exposed Secrets
Find hardcoded API keys, passwords, or tokens in the codebase.
Configure CORS
Set up proper CORS headers for an API.
Add CSRF Protection
Protect forms and endpoints from cross-site request forgery.
Set Up HTTPS
Configure SSL/TLS certificates for secure connections.
Add Rate Limit Middleware
Protect endpoints from abuse with rate limiting.
AI
Write an AI Prompt
Draft a well-structured prompt for an LLM integration.
Add Streaming Response
Implement streaming for an AI or LLM API call.
Handle AI API Errors
Add retry logic and error handling for AI API calls.
Parse AI Output
Extract structured data from an LLM response.
Add Token Counting
Track and limit token usage for AI API calls.
Performance
Add Caching
Add caching for API responses, database queries, or computed values.
Profile Performance
Measure execution time and find the slowest operations in the code.
Reduce Bundle Size
Find and remove unused code and heavy dependencies.
Optimize Images
Compress and properly size images for the web.
Find Slow Code
Identify performance bottlenecks in the codebase.
Async Python Patterns
Convert code to async/await or fix async patterns with asyncio.
Add Memoization
Cache expensive computations to avoid redundant work.
Optimize FlatList Performance
Improve FlatList or FlashList rendering performance for large datasets.
Go Benchmarks and Profiling
Add benchmarks and pprof profiling to identify performance bottlenecks.
Profile Mobile Performance
Identify and fix performance bottlenecks in a React Native app.
Optimize SwiftUI Performance
Find and fix SwiftUI performance issues — unnecessary redraws, heavy body computations, and list inefficiencies.
Monitoring
Add Logging
Add structured logging to key code paths.
Add Health Check Endpoint
Create a health check route for monitoring.
Python Logging Configuration
Set up structured logging with proper levels, formatters, and handlers.
Add Error Tracking
Integrate error reporting with a service like Sentry.
Add Performance Metrics
Instrument code with timing and counting metrics.
Add Uptime Monitoring
Set up uptime checks and alerting.
Add Request Tracing
Add distributed tracing to follow requests across services.
Go Structured Logging
Add structured logging with slog, zerolog, or zap.
DevOps
Add CI/CD Pipeline
Set up a CI/CD pipeline with build, test, lint, and deploy stages.
Dockerize This Project
Create a Dockerfile and docker-compose.yml for the project.
Add Pre-commit Hooks
Set up git hooks to lint, format, and type-check before each commit.
Add Linting Configuration
Set up ESLint, Prettier, or equivalent linting and formatting tools.
Add TypeScript to a Project
Convert a JavaScript project to TypeScript with proper configuration.
Pre-Deploy Checklist
Run through a checklist to make sure everything is ready for deployment.
Set Up Environment Management
Configure environment-specific settings and secrets.
Add Git Hooks
Set up git hooks for automated code quality checks.
Set Up Dependency Updates
Configure automated dependency update checking.
Add Code Coverage Reporting
Set up code coverage tracking and reporting.
Prepare App Store Build
Configure and run a production build for iOS App Store or Google Play.
Set Up Over-the-Air Updates
Configure EAS Update or CodePush for deploying JS updates without a store release.
Configure Nuxt Deployment
Set up Nitro presets and deployment config for Nuxt.
Docker
Go Multi-Stage Docker Build
Create a multi-stage Dockerfile for a minimal Go production image.
Running Containers
List all Docker containers that are currently running.
All Containers
List all Docker containers including stopped ones.
List Docker Images
Show all Docker images downloaded to this machine.
Start Docker Services
Start all services defined in docker-compose.yml in the background.
Stop Docker Services
Stop and remove all containers defined in docker-compose.yml.
Follow Docker Logs
Stream live logs from all Docker Compose services.
Deploy
Build and Deploy
Run the build process and deploy to the configured environment.
Start Docker Services
Bring up all Docker Compose services and verify they're running.
Preview Deployment
Deploy to a preview or staging environment for testing.
ASGI/WSGI Deployment Config
Configure gunicorn or uvicorn for production deployment.
Rollback a Deployment
Revert to the previous deployed version.
Check Deploy Status
Verify the current deployment is healthy.
Navigation
Print Working Directory
Show the full path of the directory you're currently in.
List Files
List files and folders in the current directory.
List All Files with Details
Show all files including hidden ones, with permissions, size, and dates.
List Files by Date
List files sorted by most recently modified first.
List Files by Size
List files sorted by size, largest first, with human-readable sizes.
Go Up One Directory
Move to the parent directory.
Go to Home Directory
Jump back to your home directory from anywhere.
Go to Previous Directory
Switch back to the last directory you were in.
Show Directory Tree
Display the folder structure two levels deep.
Directory Tree (skip node_modules)
Show folder structure three levels deep, ignoring node_modules.
Size of Current Directory
Show the total size of the current directory.
Size of Each Subdirectory
List subdirectories sorted by size, largest first.
Network
Node & npm
Node.js Version
Check which version of Node.js is installed.
npm Version
Check which version of npm is installed.
Installed Packages
List top-level npm packages installed in the current project.
Outdated Packages
Check which npm packages have newer versions available.
Security Audit
Scan installed packages for known security vulnerabilities.
TypeScript Type Check
Run the TypeScript compiler to check for type errors without emitting files.
Where Is Node Installed
Show the file path of the Node.js binary being used.
Processes
All Running Processes
List every process running on the system with CPU and memory usage.
Live Process Monitor
Open an interactive view of running processes, updated in real time.
Show Listening Ports
List all TCP ports that are currently listening for connections.
System
Disk Space Overview
Show how much disk space is used and available on each drive.
Clear Terminal
Clear all output from the terminal screen.
Current Username
Show which user account is currently active.
System Information
Display full system information including OS, kernel, and architecture.
System Uptime
Show how long the system has been running and current load.
Current Date and Time
Print the current date and time.
Machine Name
Show the name of the current machine.
Current Shell
Show which shell you're using (bash, zsh, etc.).
Show PATH
Display the directories the system searches for executables.
Calendar
Show the current month's calendar.
Command History
List previously run commands in this shell session.
List Aliases
Show all command aliases configured in your shell.
Python Version
Check which version of Python 3 is installed.
Installed Python Packages
List all Python packages installed in the current environment.
Add these to your Facet Inserts in Crystl for one-click access.
get Crystl