# alexop.dev

> A Personal Blog from a simple web developer

## Full Documentation

- [Full Blog Content](https://alexop.dev/llms-full.txt): Complete blog posts with full content for deep context.

## Blog

- [Why You Don't Need the Nuxt MCP When You Use Claude Code](https://alexop.dev/posts/why-you-dont-need-nuxt-mcp-claude-code): Why I use custom research agents instead of MCP servers for AI-assisted development. Learn how llms.txt enables context-efficient documentation fetching with a practical Nuxt Content agent example.
- [Claude Code customization guide: CLAUDE.md, skills, subagents explained](https://alexop.dev/posts/claude-code-customization-guide-claudemd-skills-subagents): Compare CLAUDE.md, slash commands, subagents, and skills in Claude Code. Learn when to use each with practical Dexie.js examples.
- [How to Customize Your Claude Code Status Line](https://alexop.dev/posts/customize_claude_code_status_line): Learn how to display model name, context usage, and cost directly in your terminal while using Claude Code. A step-by-step guide to creating custom status line scripts.
- [Vue 3 Testing Pyramid: A Practical Guide with Vitest Browser Mode](https://alexop.dev/posts/vue3_testing_pyramid_vitest_browser_mode): Learn a practical testing strategy for Vue 3 applications using composable unit tests, Vitest browser mode integration tests, and visual regression testing.
- [Building an AI QA Engineer with Claude Code and Playwright MCP](https://alexop.dev/posts/building_ai_qa_engineer_claude_code_playwright): Learn how to build an automated QA engineer using Claude Code and Playwright MCP that tests your web app like a real user, runs on every pull request, and writes detailed bug reports.
- [Vue Composables Style Guide: Lessons from VueUse's Codebase](https://alexop.dev/posts/vueuse_composables_style_guide): A practical guide for writing production-quality Vue 3 composables, distilled from studying VueUse's patterns for SSR safety, cleanup, and TypeScript.
- [Forcing Claude Code to TDD: An Agentic Red-Green-Refactor Loop](https://alexop.dev/posts/custom-tdd-workflow-claude-code-vue): Build a custom TDD workflow with Claude Code using skills and subagents that enforce Red-Green-Refactor discipline for your Vue projects.
- [Get Notified When Claude Code Finishes With Hooks](https://alexop.dev/posts/claude-code-notification-hooks): Set up desktop notifications in Claude Code to know when Claude needs your input or permission. Learn how to use hooks for instant alerts instead of constantly checking.
- [How to Speed Up Your Claude Code Experience with Slash Commands](https://alexop.dev/posts/claude-code-slash-commands-guide): Learn how to transform Claude Code from a chatbot into a deterministic engine using Slash Commands. This guide covers the technical setup and a complete 'Full Circle' workflow that automates your entire feature lifecycle.
- [Understanding Claude Code's Full Stack: MCP, Skills, Subagents, and Hooks Explained](https://alexop.dev/posts/understanding-claude-code-full-stack): A practical guide to Claude Code's features — explained in the order they were introduced: MCP (2024), Claude Code core (Feb 2025), Plugins (2025), and Agent Skills (Oct 2025). What each does, how they fit together, and when to use what.
- [Building My First Claude Code Plugin](https://alexop.dev/posts/building-my-first-claude-code-plugin): How I built a Claude Code plugin to generate skills, agents, commands, and more—and stopped copy-pasting boilerplate.
- [Building a Modular Monolith with Nuxt Layers: A Practical Guide](https://alexop.dev/posts/nuxt-layers-modular-monolith): Learn how to build scalable applications using Nuxt Layers to enforce clean architecture boundaries without the complexity of microservices.
- [How to Handle API Calls in Pinia with The Elm Pattern](https://alexop.dev/posts/handling-api-calls-pinia-elm-pattern): Learn how to handle API calls in Pinia using the Elm pattern for predictable, testable side effects. Includes complete examples with the Pokemon API.
- [How to Write Better Pinia Stores with the Elm Pattern](https://alexop.dev/posts/tea-architecture-pinia-private-store-pattern): Learn how to combine The Elm Architecture (TEA) principles with Pinia's private store pattern for testable, framework-agnostic state management in Vue applications.
- [How to build Microfrontends with Module Federation and Vue](https://alexop.dev/posts/how-to-build-microfrontends-with-module-federation-and-vue): Build a Vue 3 microfrontend app with Module Federation. Clear decisions, working code, and a small reference project.
- [Why You Need Something Hard in Your Life](https://alexop.dev/posts/why-you-need-something-hard-in-your-life): The biggest paradox in life: the hardest things are usually the ones that help you grow. Exploring why challenge and difficulty are essential for meaning and personal development.
- [What Is the Model Context Protocol (MCP)? How It Works](https://alexop.dev/posts/what-is-model-context-protocol-mcp): Learn how MCP (Model Context Protocol) standardizes AI tool integration, enabling LLMs to interact with external services, databases, and APIs through a universal protocol similar to USB-C for AI applications.
- [How VueUse Solves SSR Window Errors in Vue Applications](https://alexop.dev/posts/how-vueuse-solves-ssr-window-errors-vue-applications): Discover how VueUse solves SSR issues with browser APIs and keeps your Vue composables safe from 'window is not defined' errors.
- [Mastering GraphQL Fragments in Vue 3: Component-Driven Data Fetching](https://alexop.dev/posts/mastering-graphql-fragments-vue3-component-driven-data-fetching): Part 3 of the Vue 3 + GraphQL series: Learn how to use GraphQL fragments with fragment masking to create truly component-driven data fetching in Vue 3.
- [How I Use Claude Code for Doing SEO Audits](https://alexop.dev/posts/how-i-use-claude-code-for-doing-seo-audits): Learn how to leverage Claude Code with Puppeteer MCP to perform comprehensive SEO audits in minutes, complete with automated analysis and actionable reports.
- [The Age of the Generalist](https://alexop.dev/posts/the-age-of-the-generalist): How AI is transforming software development and why high-agency generalists will thrive in this new era of technology.
- [How I Use LLMs](https://alexop.dev/posts/how-i-use-llms): Learn how I use LLMs to improve my productivity and efficiency.
- [No Server, No Database: Smarter Related Posts in Astro with `transformers.js`](https://alexop.dev/posts/semantic-related-posts-astro-transformersjs): How I used Hugging Face embeddings to create smart “Related Posts” for my Astro blog—no backend, no database, just TypeScript.
- [Type-Safe GraphQL Queries in Vue 3 with GraphQL Code Generator](https://alexop.dev/posts/type-safe-graphql-queries-vue3-codegen): Part 2 of the Vue 3 + GraphQL series: generate fully-typed `useQuery` composables in Vue 3 with GraphQL Code Generator
- [LLM-Powered Search: o4-mini-high vs o3 vs Deep Research](https://alexop.dev/posts/llm-powered-search-comparison-o4-mini-high-o3-deep-research): A practical benchmark of three OpenAI models—o4-mini-high, o3, and Deep Research—for LLM-powered search. Compare their speed, depth, accuracy, citations, and cost when tackling real research questions like 'How does Vercel use Speakeasy for API testing?Ideal for developers exploring AI-assisted technical research
- [Watching OpenAI's o3 Model Sweat Over a Paul Morphy Mate-in-2](https://alexop.dev/posts/how-03-model-tries-chess-puzzle): A breakdown of how an AI model attempts to solve a complex chess puzzle, showcasing its human-like reasoning, problem-solving attempts, and eventual reliance on external information.
- [Getting Started with GraphQL in Vue 3 — Complete Setup with Apollo](https://alexop.dev/posts/getting-started-graphql-vue3-apollo-typescript): Part 1 of the Vue 3 + GraphQL series: a zero-to-hero guide for wiring up a Vue 3 app to a GraphQL API using the Composition API, Apollo Client, and Vite.
- [How ChatGPT Works (for Dummies)](https://alexop.dev/posts/how-chatgpt-works-for-dummies): A plain English guide to how ChatGPT works—from token prediction to hallucinations. Perfect for developers who want to understand the AI they're building with.
- [Stop White Box Testing Vue Components Use Testing Library Instead](https://alexop.dev/posts/stop-white-box-testing-vue): White Box testing makes your Vue tests fragile and misleading. In this post, I’ll show you how Testing Library helps you write Black Box tests that are resilient, realistic, and focused on actual user behavior
- [The Computed Inlining Refactoring Pattern in Vue](https://alexop.dev/posts/computed-inlining-refactoring-pattern-in-vue): Learn how to improve Vue component performance and readability by applying the Computed Inlining pattern - a technique inspired by Martin Fowler's Inline Function pattern.
- [Are LLMs Creative?](https://alexop.dev/posts/are-llms-creative): Exploring the fundamental nature of creativity in Large Language Models compared to human creativity, sparked by reflections on OpenAI's latest image model.
- [The Inline Vue Composables Refactoring pattern](https://alexop.dev/posts/inline-vue-composables-refactoring): Learn how to apply Martin Fowler's Extract Function pattern to Vue components using inline composables, making your code cleaner and more maintainable.
- [Math Notation from 0 to 1: A Beginner's Guide](https://alexop.dev/posts/math-notation-from-0-to-1): Learn the fundamental mathematical notations that form the building blocks of mathematical communication, from basic symbols to calculus notation.
- [How to Implement a Cosine Similarity Function in TypeScript for Vector Comparison](https://alexop.dev/posts/how-to-implement-a-cosine-similarity-function-in-typescript-for-vector-comparison): Learn how to build an efficient cosine similarity function in TypeScript for comparing vector embeddings. This step-by-step guide includes code examples, performance optimizations, and practical applications for semantic search and AI recommendation systems
- [How I Added llms.txt to My Astro Blog](https://alexop.dev/posts/how-i-added-llms-txt-to-my-astro-blog): I built a simple way to load my blog content into any LLM with one click. This post shows how you can do it too.
- [How to Do Visual Regression Testing in Vue with Vitest?](https://alexop.dev/posts/visual-regression-testing-with-vue-and-vitest-browser): Learn how to implement visual regression testing in Vue.js using Vitest's browser mode. This comprehensive guide covers setting up screenshot-based testing, creating component stories, and integrating with CI/CD pipelines for automated visual testing.
- [How to Test Vue Router Components with Testing Library and Vitest](https://alexop.dev/posts/how-to-test-vue-router-components-with-testing-library-and-vitest): Learn how to test Vue Router components using Testing Library and Vitest. This guide covers real router integration, mocked router setups, and best practices for testing navigation, route guards, and dynamic components in Vue applications.
- [How to Use AI for Effective Diagram Creation: A Guide to ChatGPT and Mermaid](https://alexop.dev/posts/how-to-use-ai-for-effective-diagram-creation-a-guide-to-chatgpt-and-mermaid): Learn how to leverage ChatGPT and Mermaid to create effective diagrams for technical documentation and communication.
- [Building a Pinia Plugin for Cross-Tab State Syncing](https://alexop.dev/posts/building-pinia-plugin-cross-tab-sync): Learn how to create a Pinia plugin that synchronizes state across browser tabs using the BroadcastChannel API and Vue 3's Script Setup syntax.
- [The Browser That Speaks 200 Languages: Building an AI Translator Without APIs](https://alexop.dev/posts/building-client-side-ai-translator-vue): Learn how to build a browser-based translator that works offline and handles 200 languages using Vue and Transformers.js
- [Solving Prop Drilling in Vue: Modern State Management Strategies](https://alexop.dev/posts/solving-prop-drilling-in-vue): Eliminate prop drilling in Vue apps using Composition API, Provide/Inject, and Pinia. Learn when to use each approach with practical examples.
- [Building Local-First Apps with Vue and Dexie.js](https://alexop.dev/posts/building-local-first-apps-vue-dexie): Learn how to create offline-capable, local-first applications using Vue 3 and Dexie.js. Discover patterns for data persistence, synchronization, and optimal user experience.
- [Unlocking Reading Insights: A Guide to Data Analysis with Claude and Readwise](https://alexop.dev/posts/supercharging-reading-comprehension-claude-readwise): Discover how to transform your reading data into actionable insights by combining Readwise exports with Claude AI's powerful analysis capabilities
- [The What Why and How of Goal Settings](https://alexop.dev/posts/the-what-why-and-how-of-goal-settings): A deep dive into the philosophy of goal-setting and personal development, exploring the balance between happiness and meaning while providing practical steps for achieving your goals in 2025.
- [XML-Style Tagged Prompts: A Framework for Reliable AI Responses](https://alexop.dev/posts/xml-tagged-prompts-framework-reliable-ai-responses): Learn how top AI engineers use XML-style prompts to consistently get structured, accurate responses from ChatGPT, Claude, and other LLMs. Step-by-step guide with real examples
- [How to Use the Variant Props Pattern in Vue](https://alexop.dev/posts/vue-typescript-variant-props-type-safe-props): Learn how to create type-safe Vue components where prop types depend on other props using TypeScript discriminated unions. A practical guide with real-world examples.
- [SQLite in Vue: Complete Guide to Building Offline-First Web Apps](https://alexop.dev/posts/sqlite-vue3-offline-first-web-apps-guide): Learn how to build offline-capable Vue 3 apps using SQLite and WebAssembly in 2024. Step-by-step tutorial includes code examples for database operations, query playground implementation, and best practices for offline-first applications.
- [Create Dark Mode-Compatible Technical Diagrams in Astro with Excalidraw: A Complete Guide](https://alexop.dev/posts/excalidraw-dark-mode-astro-diagrams): Learn how to create and integrate theme-aware Excalidraw diagrams into your Astro blog. This step-by-step guide shows you how to build custom components that automatically adapt to light and dark modes, perfect for technical documentation and blogs
- [Frontend Testing Guide: 10 Essential Rules for Naming Tests](https://alexop.dev/posts/frontend-testing-guide-10-essential-rules): Learn how to write clear and maintainable frontend tests with 10 practical naming rules. Includes real-world examples showing good and bad practices for component testing across any framework.
- [Create a Native-Like App in 4 Steps: PWA Magic with Vue 3 and Vite](https://alexop.dev/posts/create-pwa-vue3-vite-4-steps): Transform your Vue 3 project into a powerful Progressive Web App in just 4 steps. Learn how to create offline-capable, installable web apps using Vite and modern PWA techniques.
- [Atomic Architecture: Revolutionizing Vue and Nuxt Project Structure](https://alexop.dev/posts/atomic-design-vue-or-nuxt): Learn how to implement Atomic Design principles in Vue or Nuxt projects. Improve your code structure and maintainability with this guide
- [Bolt Your Presentations: AI-Powered Slides](https://alexop.dev/posts/create-ai-presentations-fast): Elevate your dev presentations with AI-powered tools. Learn to leverage Bolt, Slidev, and WebContainers for rapid, code-friendly slide creation. This guide walks developers through 7 steps to build impressive tech presentations using Markdown and browser-based Node.js. Master efficient presentation development with instant prototyping and one-click deployment to Netlify
- [10 Rules for Better Writing from the Book Economical Writing](https://alexop.dev/posts/10-rules-better-writing-economical-writing-book): Master 10 key writing techniques from Deirdre McCloskey's 'Economical Writing.' Learn to use active verbs, write clearly, and avoid common mistakes. Ideal for students, researchers, and writers aiming to communicate more effectively.
- [TypeScript Tutorial: Extracting All Keys from Nested Object](https://alexop.dev/posts/typescript-extract-all-keys-nested-objects): Learn how to extract all keys, including nested ones, from TypeScript objects using advanced type manipulation techniques. Improve your TypeScript skills and write safer code.
- [TypeScript Snippets in Astro: Show, Don't Tell](https://alexop.dev/posts/typescript-snippets-astro-show-dont-tell): Learn how to add interactive type information and syntax highlighting to TypeScript snippets in your Astro site, enhancing code readability and user experience.
- [Vue 3.5's onWatcherCleanup: Mastering Side Effect Management in Vue Applications](https://alexop.dev/posts/vue-35s-onwatchercleanup-mastering-side-effect-management-in-vue-applications): Discover how Vue 3.5's new onWatcherCleanup function revolutionizes side effect management in Vue applications
- [How to Build Your Own Vue-like Reactivity System from Scratch](https://alexop.dev/posts/how-to-build-your-own-vue-like-reactivity-system-from-scratch): Learn to build a Vue-like reactivity system from scratch, implementing your own ref() and watchEffect(). 
- [What is Local-first Web Development?](https://alexop.dev/posts/what-is-local-first-web-development): Explore the power of local-first web development and its impact on modern web applications. Learn how to build offline-capable, user-centric apps that prioritize data ownership and seamless synchronization. Discover the key principles and implementation steps for creating robust local-first web apps using Vue.
- [Vue Accessibility Blueprint: 8 Steps](https://alexop.dev/posts/vue-accessibility-blueprint-8-steps): Master Vue accessibility with our comprehensive guide. Learn 8 crucial steps to create inclusive, WCAG-compliant web applications that work for all users.
- [How to Structure Vue Projects](https://alexop.dev/posts/how-to-structure-vue-projects): Discover best practices for structuring Vue projects of any size, from simple apps to complex enterprise solutions.
- [How to Persist User Data with LocalStorage in Vue](https://alexop.dev/posts/how-to-persist-user-data-with-localstorage-in-vue): Learn how to efficiently store and manage user preferences like dark mode in Vue applications using LocalStorage. This guide covers basic operations, addresses common challenges, and provides type-safe solutions for robust development.
- [How to Write Clean Vue Components](https://alexop.dev/posts/how-to-write-clean-vue-components): There are many ways to write better Vue components. One of my favorite ways is to separate business logic into pure functions.
- [The Problem with as in TypeScript: Why It's a Shortcut We Should Avoid](https://alexop.dev/posts/the-problem-with-as-in-typescript-why-its-a-shortcut-we-should-avoid): Learn why as can be a Problem in Typescript
- [Exploring the Power of Square Brackets in TypeScript](https://alexop.dev/posts/exploring-the-power-of-square-brackets-in-typescript): TypeScript, a statically-typed superset of JavaScript, implements square brackets [] for specific purposes. This post details the essential applications of square brackets in TypeScript, from array types to complex type manipulations, to help you write type-safe code.
- [How to Test Vue Composables: A Comprehensive Guide with Vitest](https://alexop.dev/posts/how-to-test-vue-composables): Learn how to effectively test Vue composables using Vitest. Covers independent and dependent composables, with practical examples and best practices.
- [Robust Error Handling in TypeScript: A Journey from Naive to Rust-Inspired Solutions](https://alexop.dev/posts/robust-error-handling-in-typescript-a-journey-from-naive-to-rust-inspired-solutions): Learn to write robust, predictable TypeScript code using Rust's Result pattern. This post demonstrates practical examples and introduces the ts-results library, implementing Rust's powerful error management approach in TypeScript.
- [Mastering Vue 3 Composables: A Comprehensive Style Guide](https://alexop.dev/posts/mastering-vue-3-composables-a-comprehensive-style-guide): Did you ever struggle how to write better composables in Vue? In this Blog post I try to give some tips how to do that
- [Best Practices for Error Handling in Vue Composables](https://alexop.dev/posts/best-practices-for-error-handling-in-vue-composables): Error handling can be complex, but it's crucial for composables to manage errors consistently. This post explores an effective method for implementing error handling in composables.
- [How to Improve Accessibility with Testing Library and jest-axe for Your Vue Application](https://alexop.dev/posts/how-to-improve-accessibility-with-testing-library-and-jest-axe-for-your-vue-application): Use Jest axe to have automatic tests for your vue application
- [Mastering TypeScript: Looping with Types](https://alexop.dev/posts/mastering-typescript-looping-with-types): Did you know that TypeScript is Turing complete? In this post, I will show you how you can loop with TypeScript.

## TIL (Today I Learned)

- [TIL - Blending Fuzzy and Semantic Search with Reciprocal Rank Fusion](https://alexop.dev/tils/reciprocal-rank-fusion-typescript-vue): Learn how to merge fuzzy and semantic search results using Reciprocal Rank Fusion (RRF) with TypeScript implementation and interactive Vue demo
- [Indexed v-model in Vue 3](https://alexop.dev/tils/indexed-v-model-in-vue-3): TIL about handling any number of inputs with one reactive array by binding each field to array[index] in Vue 3.
- [TIL - Detecting fresh deployments in a Vue 3 SPA with vite + version.json](https://alexop.dev/tils/detecting-fresh-deployments-vue3-spa-vite-version-json): Learn how to detect fresh deployments in a Vue 3 SPA with vite + version.json
- [TIL: TypeScript Function Overloads](https://alexop.dev/tils/typescript-function-overloads): Today I learned about function overloads in TypeScript. They solve a common problem - making your code understand exactly what type comes out based on what type goes in.
- [TIL: Powerful Vue.js Patterns for Complex JSON Rendering](https://alexop.dev/tils/using-provide-inject-and-recursive-components-in-vuejs): Key insights on using provide/inject and recursive components to build a JSON viewer in Vue.js
- [TypeScript Type Extraction Patterns](https://alexop.dev/tils/typescript-type-extraction-patterns): Learn powerful TypeScript patterns for extracting and transforming nested types from complex interfaces.
- [Better Type Inference with TypeScript Array Filters](https://alexop.dev/tils/typescript-array-filter-type-inference): How to improve TypeScript type inference when filtering arrays using type guards
- [Deploy your Vue App to GitHub Pages with Caching](https://alexop.dev/tils/github-actions-vue-deployment-caching): Learn how to speed up your GitHub Actions workflows by caching node_modules and properly deploy Vue apps to GitHub Pages
- [Dynamic Pinia Stores in Vue 3](https://alexop.dev/tils/dynamic-pinia-stores): Create dynamic Pinia stores with unique IDs for separate component instances

## Notes

- [Software Testing with Generative AI](https://alexop.dev/notes/software-testing-with-generative-ai): A beginner friendly guide for leveraging AI in software testing practices

## Prompts

- [Conventional Commit](https://alexop.dev/prompts/claude/claude-conventional-commit): Slash command to create conventional commit messages and commit staged changes following the conventional commits specification
- [Create Plugin](https://alexop.dev/prompts/claude/claude-create-plugin): Slash command to convert a project into a properly structured Claude Code plugin with marketplace configuration
- [Create Command](https://alexop.dev/prompts/claude/claude-create-command): Slash command to generate properly structured slash command files for Claude Code with standardized structure
- [Create CLAUDE.md Documentation](https://alexop.dev/prompts/claude/claude-create-md): Slash command to analyze project structure and generate CLAUDE.md files for project documentation and coding guidelines
- [Create Agent Command](https://alexop.dev/prompts/claude/claude-create-agent): Slash command to create custom subagents for specialized tasks with proper configuration and system prompts
- [Create Hook](https://alexop.dev/prompts/claude/claude-create-hook): Slash command to create and configure Claude Code hooks with reference documentation and interactive guidance
- [Create Output Style](https://alexop.dev/prompts/claude/claude-create-output-style): Slash command to generate custom output styles that modify Claude Code's system prompt for different agent behaviors
- [Create Skill](https://alexop.dev/prompts/claude/claude-create-skill): Slash command to generate new Claude Skills with proper structure, YAML frontmatter, and bundled resources
- [Nuxt Content Documentation Reference Skill](https://alexop.dev/prompts/claude/claude-nuxt-content-skill): Skill that ensures Claude fetches current Nuxt Content documentation before answering questions or implementing features
- [Commit: Create Conventional Commit Message](https://alexop.dev/prompts/claude/claude-commit-command): Analyzes staged and unstaged changes to create a well-formatted conventional commit message
- [Branch: Create Feature Branch from Main](https://alexop.dev/prompts/claude/claude-branch-command): Creates a new branch from main with conventional commit-style naming based on a task description
- [Fix Pipeline: Systematic CI/CD Debugging](https://alexop.dev/prompts/claude/claude-fix-pipeline-command): Agent that systematically debugs CI pipeline failures using root cause analysis before implementing fixes
- [Lint: Auto-fix and Resolve Linting Issues](https://alexop.dev/prompts/claude/claude-lint-command): Runs linter with auto-fix enabled and resolves any remaining errors that require manual intervention
- [Merge to Main: Complete PR Workflow](https://alexop.dev/prompts/claude/claude-merge-to-main-command): Merges current branch to main via GitHub PR with squash merge and branch cleanup
- [PR: Create Well-Formatted Pull Request](https://alexop.dev/prompts/claude/claude-pr-command): Creates a GitHub PR with conventional title and structured description including summary, changes, and test plan
- [Push: Commit and Push to Remote](https://alexop.dev/prompts/claude/claude-push-command): Combines commit creation with conventional message and push to remote in one command
- [Refactor Page Object: Test Pattern Refactoring](https://alexop.dev/prompts/claude/claude-refactor-page-object-command): Refactors Vue component tests to use the Page Object Pattern for better maintainability and readability
- [Review CodeRabbit: Process AI Code Reviews](https://alexop.dev/prompts/claude/claude-review-coderabbit-command): Agent that processes CodeRabbit review comments with technical rigor - verifies suggestions before implementing and pushes back when wrong
- [Vitest: Run Tests and Fix Failures](https://alexop.dev/prompts/claude/claude-vitest-command): Runs Vitest test suite and systematically fixes any failing tests
- [Create Command: Scaffold New Slash Commands](https://alexop.dev/prompts/claude/claude-create-slash-command): Interactive agent that scaffolds new slash commands with best practices, proper frontmatter, and structured templates
- [Genereate new Prompt for Copilot](https://alexop.dev/prompts/copilot/copilot-make-prompt): Custom instructions for TypeScript development with strict typing