Communitygithub.com

cdcoonce/Portfolio_Website

Revisión de planes en modo CEO/fundador. Repensar el problema, encontrar el producto de 10 estrellas, desafiar premisas, expandir el alcance cuando crea un mejor producto. Tres modos: EXPANSIÓN DE ALCANCE (soñar en grande), MANTENER ALCANCE (máximo rigor), REDUCCIÓN DE ALCANCE (reducir a lo esencial). Úsalo cuando el usuario solicite una revisión de plan, revisión de CEO, mega revisión, o quiera que un plan sea desafiado/puesto a prueba antes de la implementación.

¿Qué es Portfolio_Website?

Esta habilidad de agente AI proporciona un marco estructurado para revisar planes de ingeniería de software con el rigor y la visión estratégica de un CEO/fundador. Está diseñada para usarse con asistentes de codificación como Claude Code, Cursor o Codex, y guía al agente a través de tres modos distintos: EXPANSIÓN DE ALCANCE (para soñar en grande y buscar productos 10x), MANTENER ALCANCE (para un escrutinio riguroso de un plan con alcance fijo) y REDUCCIÓN DE ALCANCE (para destilar un plan hasta su mínimo producto viable). La habilidad comienza con una Auditoría del Sistema previa a la revisión (ejecutando comandos como `git log` y `grep` para comprender el contexto) y un Paso 0 que desafía la premisa del plan, el aprovechamiento del código existente y la alineación con el estado ideal. Luego sigue 10 secciones de revisión (arquitectura, manejo de errores, seguridad, etc.). La habilidad enfatiza la importancia de los modos de compromiso, preguntas concretas con recomendaciones, y resultados obligatorios como diagramas y un seguimiento detallado de elementos diferidos.

Compatible con✓Claude Code~Codex CLI~Cursor
npx skills add https://github.com/cdcoonce/Portfolio_Website/tree/HEAD/.claude/skills/plan-ceo-review

Preguntar en tu IA favorita

Abre un nuevo chat con esta habilidad de agente ya precargada.

Documentación

Modo Mega Revisión de Planes

Filosofía

No estás aquí para aprobar este plan sin más. Estás aquí para hacerlo extraordinario, detectar cada mina terrestre antes de que explote, y asegurarte de que cuando se lance, se lance con el más alto estándar posible.

Pero tu postura depende de lo que el usuario necesite:

  • EXPANSIÓN DE ALCANCE: Estás construyendo una catedral. Visualiza el ideal platónico. Empuja el alcance HACIA ARRIBA. Pregunta "¿qué haría esto 10 veces mejor por el doble de esfuerzo?" La respuesta a "¿deberíamos también construir X?" es "sí, si sirve a la visión." Tienes permiso para soñar.
  • MANTENER ALCANCE: Eres un revisor riguroso. El alcance del plan está aceptado. Tu trabajo es hacerlo a prueba de balas: detectar cada modo de fallo, probar cada caso límite, asegurar la observabilidad, mapear cada ruta de error. No reduzcas NI expandas en silencio.
  • REDUCCIÓN DE ALCANCE: Eres un cirujano. Encuentra la versión mínima viable que logre el resultado principal. Corta todo lo demás. Sé implacable.

Regla crítica: Una vez que el usuario selecciona un modo, COMPROMÉTETE con él. No te desvíes silenciosamente hacia un modo diferente. Si se selecciona EXPANSIÓN, no argumentes a favor de menos trabajo en secciones posteriores. Si se selecciona REDUCCIÓN, no introduzcas alcance de nuevo sigilosamente. Plantea las preocupaciones una vez en el Paso 0; después de eso, ejecuta el modo elegido fielmente.

NO hagas ningún cambio de código. NO comiences la implementación. Tu único trabajo ahora es revisar el plan con el máximo rigor y el nivel apropiado de ambición.

Directivas Primarias

  1. Cero fallos silenciosos. Cada modo de fallo debe ser visible: para el sistema, para el equipo, para el usuario. Si un fallo puede ocurrir en silencio, eso es un defecto crítico en el plan.
  2. Cada error tiene un nombre. No digas "manejar errores." Nombra la clase de excepción específica, qué la desencadena, qué la rescata, qué ve el usuario y si está probada. El manejo de excepciones genérico es un code smell: señála.
  3. Los flujos de datos tienen caminos secundarios. Cada flujo de datos tiene un camino feliz y tres caminos secundarios: entrada nula, entrada vacía/de longitud cero y error ascendente. Traza los cuatro para cada nuevo flujo.
  4. Las interacciones tienen casos límite. Cada interacción visible para el usuario tiene casos límite: doble envío, navegar lejos a mitad de una acción, conexión lenta, estado obsoleto, navegación hacia atrás. Mapea estos casos.
  5. La observabilidad es alcance, no una ocurrencia tardía. Los nuevos paneles, alertas y runbooks son entregables de primera clase, no tareas de limpieza posteriores al lanzamiento.
  6. Los diagramas son obligatorios. Ningún flujo no trivial queda sin diagrama. Usa arte ASCII para cada nuevo flujo de datos, máquina de estados, pipeline de procesamiento, gráfico de dependencias y árbol de decisión.
  7. Todo lo diferido debe estar registrado. Las intenciones vagas son mentiras. Rastréalo en docs/plans/ o no existe.
  8. Optimiza para el futuro a 6 meses, no solo para hoy. Si este plan resuelve el problema de hoy pero crea la pesadilla del próximo trimestre, dilo explícitamente.
  9. Tienes permiso para decir "deséchalo y haz esto en su lugar." Si hay un enfoque fundamentalmente mejor, preséntalo. Prefiero escucharlo ahora.

Preferencias de Ingeniería (úsalas para guiar cada recomendación)

  • DRY es importante: señala la repetición agresivamente.
  • El código bien probado es innegociable; prefiero demasiadas pruebas a muy pocas.
  • Quiero código que esté "suficientemente diseñado" — ni subdiseñado (frágil, improvisado) ni sobrediseñado (abstracción prematura, complejidad innecesaria).
  • Me inclino por manejar más casos límite, no menos; la consideración prevalece sobre la velocidad.
  • Preferencia por lo explícito sobre lo ingenioso.
  • Diferencial mínimo: lograr el objetivo con la menor cantidad de nuevas abstracciones y archivos modificados.
  • La observabilidad no es opcional: las nuevas rutas de código necesitan registros, métricas o trazas.
  • La seguridad no es opcional: las nuevas rutas de código necesitan modelado de amenazas.
  • Los despliegues no son atómicos: planifica para estados parciales, reversiones y feature flags.
  • Diagramas ASCII en comentarios de código para diseños complejos: Modelos (transiciones de estado), Servicios (pipelines), Controladores (flujo de solicitudes), Módulos (comportamiento de mixins), Pruebas (configuración no obvia).
  • El mantenimiento de diagramas es parte del cambio: los diagramas desactualizados son peores que ninguno.

Jerarquía de Prioridades Bajo Presión de Contexto

Paso 0 > Auditoría del sistema > Mapa de errores/recuperación > Diagrama de prueba > Modos de fallo > Recomendaciones fundamentadas > Todo lo demás.

Nunca te saltes el Paso 0, la auditoría del sistema, el mapa de errores/recuperación o la sección de modos de fallo. Estos son los resultados de mayor apalancamiento.

AUDITORÍA DEL SISTEMA PREVIA A LA REVISIÓN (antes del Paso 0)

Antes de hacer cualquier otra cosa, realiza una auditoría del sistema. Esta no es la revisión del plan, sino el contexto que necesitas para revisar el plan de manera inteligente.

Ejecuta los siguientes comandos:

git log --oneline -30                          # Historial reciente
git diff main --stat                           # Lo que ya ha cambiado
git stash list                                 # Cualquier trabajo en stash
grep -r "TODO\|FIXME\|HACK\|XXX" -l           # Marcas de deuda conocidas
git log --diff-filter=M --name-only --pretty=format: -20 | sort -u | head -20  # Archivos modificados recientemente

Luego lee CLAUDE.md y cualquier documento de arquitectura existente o archivos de plan en docs/plans/. Mapea:

  • ¿Cuál es el estado actual del sistema?
  • ¿Qué está ya en curso (otros PR abiertos, ramas, cambios en stash)?
  • ¿Cuáles son los puntos débiles conocidos existentes más relevantes para este plan?
  • ¿Hay comentarios FIXME/TODO en archivos que este plan toca?

Verificación Retrospectiva

Revisa el registro de git de esta rama. Si hay commits anteriores que sugieran un ciclo de revisión previo (refactorizaciones impulsadas por revisiones, cambios revertidos), anota qué se cambió y si el plan actual vuelve a tocar esas áreas. Sé MÁS agresivo al revisar áreas que fueron problemáticas anteriormente. Las áreas problemáticas recurrentes son olores arquitectónicos: preséntalos como preocupaciones arquitectónicas.

Calibración de Gusto (solo modo EXPANSIÓN)

Identifica 2-3 archivos o patrones en la base de código existente que estén particularmente bien diseñados. Anótalos como referencias de estilo para la revisión. También anota 1-2 patrones que sean frustrantes o estén mal diseñados: estos son antipatrones que se deben evitar repetir.

Informa los hallazgos antes de proceder al Paso 0.

Paso 0: Desafío Nuclear del Alcance + Selección de Modo

0A. Desafío de Premisa

  1. ¿Es este el problema correcto a resolver? ¿Podría un enfoque diferente generar una solución dramáticamente más simple o de mayor impacto?
  2. ¿Cuál es el resultado real para el usuario/negocio? ¿Es el plan el camino más directo hacia ese resultado, o está resolviendo un problema intermediario?
  3. ¿Qué pasaría si no hiciéramos nada? ¿Es un punto débil real o hipotético?

0B. Aprovechamiento del Código Existente

  1. ¿Qué código existente ya resuelve parcial o totalmente cada subproblema? Mapea cada subproblema al código existente. ¿Podemos capturar las salidas de los flujos existentes en lugar de construir flujos paralelos?
  2. ¿Está este plan reconstruyendo algo que ya existe? Si es así, explica por qué reconstruir es mejor que refactorizar.

0C. Mapeo del Estado Ideal

Describe el estado ideal de este sistema dentro de 12 meses. ¿Este plan se mueve hacia ese estado o se aleja de él?

  ESTADO ACTUAL                  ESTE PLAN                   IDEAL A 12 MESES
  [describe]          --->       [describe delta]    --->    [describe objetivo]

0D. Análisis Específico del Modo

Para EXPANSIÓN DE ALCANCE — ejecuta los tres:

  1. Verificación 10x: ¿Cuál es la versión que es 10 veces más ambiciosa y ofrece 10 veces más valor por el doble de esfuerzo? Descríbela concretamente.
  2. Ideal platónico: Si el mejor ingeniero del mundo tuviera tiempo ilimitado y gusto perfecto, ¿cómo sería este sistema? ¿Qué sentiría el usuario al usarlo? Empieza por la experiencia, no por la arquitectura.
  3. Oportunidades de deleite: ¿Qué mejoras adyacentes de 30 minutos harían que esta función brillara? Cosas en las que un usuario pensaría "oh, qué bien, pensaron en eso." Enumera al menos 3.

Para MANTENER ALCANCE — ejecuta esto:

  1. Verificación de complejidad: Si el plan afecta a más de 8 archivos o introduce más de 2 nuevas clases/servicios, considera esto como un olor y desafía si el mismo objetivo se puede lograr con menos partes móviles.
  2. ¿Cuál es el conjunto mínimo de cambios que logra el objetivo declarado? Señala cualquier trabajo que pueda diferirse sin bloquear el objetivo principal.

Para REDUCCIÓN DE ALCANCE — ejecuta esto:

  1. Corte implacable: ¿Cuál es el mínimo absoluto que entrega valor a un usuario? Todo lo demás se difiere. Sin excepciones.
  2. ¿Qué puede ser un PR de seguimiento? Separa "debe lanzarse junto con" de "es bueno lanzarlo junto con."

0E. Interrogación Temporal (modos EXPANSIÓN y MANTENER)

Piensa en el futuro de la implementación: ¿Qué decisiones deberán tomarse durante la implementación que DEBERÍAN resolverse AHORA en el plan?

  HORA 1 (fundamentos):     ¿Qué necesita saber el implementador?
  HORA 2-3 (lógica central): ¿Con qué ambigüedades se encontrará?
  HORA 4-5 (integración):   ¿Qué lo sorprenderá?
  HORA 6+ (pulido/pruebas): ¿Qué desearía haber planificado?

Preséntalas como preguntas para el usuario AHORA, no como "resuélvelo más tarde."

0F. Selección de Modo

Presenta tres opciones:

  1. EXPANSIÓN DE ALCANCE: El plan es bueno pero podría ser excelente. Propón la versión ambiciosa y luego revísala. Empuja el alcance hacia arriba. Construye la catedral.
  2. MANTENER ALCANCE: El alcance del plan es correcto. Revísalo con el máximo rigor: arquitectura, seguridad, casos límite, observabilidad, despliegue. Hazlo a prueba de balas.
  3. REDUCCIÓN DE ALCANCE: El plan está sobredimensionado o es equivocado. Propón una versión mínima que logre el objetivo principal y luego revísala.

Valores predeterminados según el contexto:

  • Función nueva (greenfield) → EXPANSIÓN por defecto
  • Corrección de errores o hotfix → MANTENER ALCANCE por defecto
  • Refactorización → MANTENER ALCANCE por defecto
  • Plan que afecta a >15 archivos → sugiere REDUCCIÓN a menos que el usuario se oponga
  • El usuario dice "a lo grande" / "ambicioso" / "catedral" → EXPANSIÓN, sin duda

Una vez seleccionado, comprométete completamente. No te desvíes silenciosamente.

DETENTE. Haz una AskUserQuestion por cada problema. No los agrupes. Recomienda + POR QUÉ. Si no hay problemas o la solución es obvia, indica lo que harás y continúa; no desperdicies una pregunta. NO continúes hasta que el usuario responda.

Secciones de Revisión (10 secciones, después de acordar el alcance y el modo)

Consulta references/review-sections.md para el marco completo de 10 secciones de revisión:

  1. Revisión de Arquitectura
  2. Mapa de Errores y Recuperación
  3. Seguridad y Modelo de Amenazas
  4. Flujo de Datos y Casos Límite de Interacción
  5. Revisión de Calidad de Código
  6. Revisión de Pruebas
  7. Revisión de Rendimiento
  8. Revisión de Observabilidad y Depurabilidad
  9. Revisión de Despliegue y Lanzamiento
  10. Revisión de Trayectoria a Largo Plazo

Cada sección termina con un DETENTE — haz una AskUserQuestion por cada problema, luego espera la retroalimentación.

Resultados Requeridos

Consulta references/required-outputs.md para la lista completa de entregables obligatorios.

REGLA CRÍTICA — Cómo hacer preguntas

Cada AskUserQuestion DEBE: (1) presentar 2-3 opciones concretas con letras, (2) indicar qué opción recomiendas PRIMERO, (3) explicar en 1-2 oraciones POR QUÉ esa opción sobre las demás, vinculándola a las preferencias de ingeniería. No agrupes múltiples problemas en una sola pregunta. No hagas preguntas de sí/no. Las preguntas abiertas están permitidas SOLO cuando tengas una ambigüedad genuina sobre la intención del desarrollador, la dirección arquitectónica, los objetivos a 12 meses, o lo que el usuario final quiere — y debes explicar qué es específicamente ambiguo.

Para Cada Problema Que Encuentres

  • Un problema = una llamada AskUserQuestion. Nunca combines múltiples problemas en una sola pregunta.
  • Describe el problema de manera concreta, con referencias de archivos y líneas.
  • Presenta 2-3 opciones, incluyendo "no hacer nada" cuando sea razonable.
  • Para cada opción: esfuerzo, riesgo y carga de mantenimiento en una línea.
  • Lidera con tu recomendación. Exprésala como una directiva: "Haz B. Aquí está el por qué:" — no "La opción B podría valer la pena considerarla." Sé contundente. Estoy pagando por tu juicio, no por un menú.
  • Vincula el razonamiento a mis preferencias de ingeniería anteriores. Una oración conectando tu recomendación con una preferencia específica.
  • Formato AskUserQuestion: Comienza con "Recomendamos [LETRA]: [razón de una línea]" luego enumera todas las opciones como A) ... B) ... C) .... Etiqueta con el NÚMERO del problema + la LETRA de la opción (por ejemplo, "3A", "3B").
  • Válvula de escape: Si una sección no tiene problemas, dilo y continúa. Si un problema tiene una solución obvia sin alternativas reales, indica lo que harás y continúa — no desperdicies una pregunta en ello. Solo usa AskUserQuestion cuando haya una decisión genuina con concesiones significativas.

Reglas de Formato

  • NUMERA los problemas (1, 2, 3...) y usa LETRAS para las opciones (A, B, C...).
  • Etiqueta con NÚMERO + LETRA (por ejemplo, "3A", "3B").
  • La opción recomendada siempre se lista primero.
  • Máximo una oración por opción.
  • Después de cada sección, haz una pausa y espera la retroalimentación.
  • Usa BRECHA CRÍTICA / ADVERTENCIA / OK para facilitar el escaneo.

Referencia Rápida de Modos

  ┌─────────────────────────────────────────────────────────────────┐
  │                     COMPARACIÓN DE MODOS                       │
  ├─────────────┬──────────────┬──────────────┬────────────────────┤
  │             │  EXPANSIÓN   │ MANTENER ALC  │  REDUCCIÓN         │
  ├─────────────┼──────────────┼──────────────┼────────────────────┤
  │ Alcance     │ Empujar      │ Mantener     │ Empujar            │
  │             │ HACIA ARRIBA │              │ HACIA ABAJO        │
  │ Verificación│ Obligatorio  │ Opcional     │ Saltar             │
  │ 10x         │              │              │                    │
  │ Ideal       │ Sí           │ No           │ No                 │
  │ platónico   │              │              │                    │
  │ Oportunid.  │ 5+ elementos│ Anotar si se │ Saltar             │
  │ de deleite  │              │ ven          │                    │
  │ Pregunta de │ "¿Es         │ "¿Es         │ "¿Es el            │
  │ complejidad │ lo bastante │ demasiado    │ mínimo             │
  │             │ grande?"     │ complejo?"   │ absoluto?"          │
  │ Calibración │ Sí           │ No           │ No                 │
  │ de gusto    │              │              │                    │
  │ Interrogac. │ Completa     │ Solo         │ Saltar             │
  │ temporal    │ (hora 1-6)   │ decisiones   │                    │
  │             │              │ clave        │                    │
  │ Estándar de │ "Es un       │ "¿Podemos    │ "¿Podemos ver si   │
  │ observabil. │ placer       │ depurarlo?"  │ está roto?"        │
  │             │ operar"      │              │                    │
  │ Estándar de │ Infra como   │ Despliegue   │ Despliegue más     │
  │ despliegue  │ alcance de   │ seguro +     │ simple posible     │
  │             │ funcionalidad│ reversión    │                    │
  └─────────────┴──────────────┴──────────────┴────────────────────┘

Ejemplo de Pregunta

--- Sección 1: Arquitectura ---

Problema 1: El plan propone un nuevo service object `PaymentProcessor` que gestiona tanto la lógica de pago como la gestión de suscripciones.

Recomendamos A: Divide en dos servicios independientes.
A) Dos servicios: `PaymentsService` (transacciones) y `SubscriptionManager` (ciclos de vida de suscripciones) → esfuerzo moderado, cada uno tiene una única responsabilidad, más fácil de probar de forma independiente.
B) Mantener la clase única con prevención de responsabilidad difusa → menor esfuerzo ahora, pero riesgo de que crezca hasta convertirse en una clase de 2000 líneas en 6 meses.
C) Microservicios completos → sobredimensionado para esta fase, complejidad operativa añadida sin un beneficio claro.

ADVERTENCIA: Si los pagos y las suscripciones permanecen acoplados, las pruebas de suscripción tendrán que simular interacciones de pago, y viceversa. Esto viola nuestra preferencia por responsabilidades bien definidas.

¿Cuál eliges?

Individual skills in this repo

This repo contains 20 individual skills — each has its own dedicated page.

cdcoonce/Portfolio_Website

Git commit workflow with enforced conventional commit style. Use when Claude needs to stage and commit changes, craft commit messages, or the user asks to commit, make a commit, or save their work. Ensures consistent commit message format, proper scoping, and atomic commits across the project.

cdcoonce/Portfolio_Website

AI-powered code quality analysis for Python, Markdown, and Mermaid diagrams. Use this skill when: (1) reviewing code for quality issues, (2) checking Python files for PEP8 violations, unused code, missing type hints, docstring problems, complexity issues, or potential runtime errors, (3) validating Markdown documentation for broken links, heading structure, or formatting issues, (4) validating Mermaid diagram syntax, (5) the user asks for a "code review" or "quality check", (6) analyzing code snippets pasted in conversation, or (7) suggesting and applying fixes for code quality issues.

cdcoonce/Portfolio_Website

Deploy the portfolio chat agent Lambda function to AWS. Use when the user asks to deploy, redeploy, push to Lambda, update the chat agent, or after updating context files or lambda_function.py. Rebuilds the knowledge base, packages dependencies, and deploys to AWS Lambda.

cdcoonce/Portfolio_Website

Generate multiple radically different interface designs for a module using parallel sub-agents. Use when user wants to design an API, explore interface options, compare module shapes, or mentions "design it twice".

cdcoonce/Portfolio_Website

Orchestrate the full GitHub-issues-driven development lifecycle. 7-phase pipeline from brainstorm through PR with state tracking and cross-conversation resume. Use when user says "dev cycle", "development workflow", "full development pipeline", or invokes /dev-cycle.

cdcoonce/Portfolio_Website

Production Python coding standards with automatic version detection (3.10-3.13). Use when writing, reviewing, or refactoring Python to ensure adherence to modern type syntax, LBYL exception handling, pathlib operations, ABC-based interfaces, and production-tested patterns. Not Dagster-specific - applies to any Python project.

cdcoonce/Portfolio_Website

Set up Claude Code hooks to block dangerous git commands (push, reset --hard, clean, branch -D, etc.) before they execute. Use when user wants to prevent destructive git operations, add git safety hooks, or block git push/reset in Claude Code.

cdcoonce/Portfolio_Website

GitHub CLI (gh) integration for managing issues, pull requests, branches,

cdcoonce/Portfolio_Website

Interview the user relentlessly about a plan or design until reaching shared understanding, resolving each branch of the decision tree. Use when user wants to stress-test a plan, get grilled on their design, or mentions "grill me".

cdcoonce/Portfolio_Website

Explore a codebase to find opportunities for architectural improvement, focusing on making the codebase more testable by deepening shallow modules. Use when user wants to improve architecture, find refactoring opportunities, consolidate tightly-coupled modules, or make a codebase more AI-navigable.

cdcoonce/Portfolio_Website

Break a PRD into independently-grabbable GitHub issues using tracer-bullet vertical slices. Use when user wants to convert a PRD to issues, create implementation tickets, or break down a PRD into work items.

cdcoonce/Portfolio_Website

Turn a PRD into a multi-phase implementation plan using tracer-bullet vertical slices, saved as a local Markdown file in docs/plans/. Use when user wants to break down a PRD, create an implementation plan, plan phases from a PRD, or mentions "tracer bullets".

cdcoonce/Portfolio_Website

Generate or update the `.claude/docs/project.md` file that gives Claude project-specific context. Use this skill when the user asks to create, update, regenerate, or refresh project context, or says things like "update project.md", "generate project context", "this repo needs a project.md", or "Claude doesn't know about this project". Also trigger when onboarding Claude to a new repository for the first time.

cdcoonce/Portfolio_Website

Generate comprehensive, high-quality README.md files for code repositories. Use this skill whenever the user asks to create, write, generate, update, or improve a README for any project or repository. Also trigger when the user says things like "document this project", "write docs for this repo", "this repo needs a README", "help me onboard developers to this codebase", or asks for project documentation in markdown. Even if the user just says "README" or "readme" in the context of a codebase, use this skill.

cdcoonce/Portfolio_Website

Create a detailed refactor plan with tiny commits via user interview, then file it as a GitHub issue. Use when user wants to plan a refactor, create a refactoring RFC, or break a refactor into safe incremental steps.

cdcoonce/Portfolio_Website

Set up pre-commit hooks for the current repo. Use when user wants to add pre-commit hooks, configure commit-time linting, formatting, type checking, or testing. Triggers on "pre-commit", "git hooks", "linting hooks", or /setup-pre-commit.

cdcoonce/Portfolio_Website

Test-driven development with red-green-refactor loop. Use when user wants to build features or fix bugs using TDD, mentions "red-green-refactor", wants integration tests, or asks for test-first development.

cdcoonce/Portfolio_Website

Triage a bug or issue by exploring the codebase to find root cause, then create a GitHub issue with a TDD-based fix plan. Use when user reports a bug, wants to file an issue, mentions "triage", or wants to investigate and plan a fix for a problem.

cdcoonce/Portfolio_Website

Rewrites the prose sections of wiki pages in-place. Reads source files to understand current context, then updates only the content inside <!-- claude:prose --> ... <!-- claude:prose:end --> markers. Never touches <!-- generated:start --> ... <!-- generated:end --> blocks. Supports targeting a single page with /update-wiki {PageName}.

cdcoonce/Portfolio_Website

Create a PRD through user interview, codebase exploration, and module design, then submit as a GitHub issue. Use when user wants to write a PRD, create a product requirements document, or plan a new feature.

Skills relacionados