avila-tek-skill-pack

Implement the next task incrementally — build, test, verify, commit

Simplify code for clarity and maintainability — reduce complexity without changing behavior

Generate or update the Domain Model (docs/domain_model.md) from project context and interactive Q&A

Generate Epic documents (epic.md) from a Spec Funcional — one folder per epic

Generate a Functional Spec (Spec Funcional) in Spanish from a Design Doc — one per epic

Configure development harness tooling — linters, static analysis, and self-check rules that let the agent catch violations automatically during build

Break work into small verifiable tasks with acceptance criteria and dependency ordering

Generate or update the Project Master Context (docs/project_context.md) from a Design Doc or Intake Brief

Conduct a five-axis code review — correctness, readability, architecture, security, performance

Run the pre-launch checklist and prepare for production deployment

Start spec-driven development — write a structured specification before writing code

Generate Story files for an epic — one folder per story under docs/epics/E-XXX/stories/

Generate a Technical Design Document (TDD) from a Spec Funcional and domain model

Refactor an existing test suite — snapshot, classify, restructure module by module, compare.

Run TDD workflow — write failing tests, implement, verify. For bugs, use the Prove-It pattern.

Sync epics and stories from the repo to Lark Base via the Avila Tools API

QA engineer specialized in test strategy, test writing, and coverage analysis. Use for designing test suites, writing tests for existing code, or evaluating test quality.

Senior code reviewer that evaluates changes across five dimensions — correctness, readability, architecture, security, and performance. Use for thorough code review before merge.

Security engineer focused on vulnerability detection, threat modeling, and secure coding practices. Use for security-focused code review, threat analysis, or hardening recommendations.

Guides stable API and interface design. Use when designing APIs, module boundaries, or any public interface. Use when creating REST or GraphQL endpoints, defining type contracts between modules, or establishing boundaries between frontend and backend.

Tests in real browsers. Use when building or debugging anything that runs in a browser. Use when you need to inspect the DOM, capture console errors, analyze network requests, profile performance, or verify visual output with real runtime data via Chrome DevTools MCP.

Automates CI/CD pipeline setup. Use when setting up or modifying build and deployment pipelines. Use when you need to automate quality gates, configure test runners in CI, or establish deployment strategies.

Conducts multi-axis code review. Use before merging any change. Use when reviewing code written by yourself, another agent, or a human. Use when you need to assess code quality across multiple dimensions before it enters the main branch.

Simplifies code for clarity. Use when refactoring code for clarity without changing behavior. Use when code works but is harder to read, maintain, or extend than it should be. Use when reviewing code that has accumulated unnecessary complexity.

Optimizes agent context setup. Use when starting a new session, when agent output quality degrades, when switching between tasks, or when you need to configure rules files and context for a project.

Guides systematic root-cause debugging. Use when tests fail, builds break, behavior doesn't match expectations, or you encounter any unexpected error. Use when you need a systematic approach to finding and fixing the root cause rather than guessing.

Manages deprecation and migration. Use when removing old systems, APIs, or features. Use when migrating users from one implementation to another. Use when deciding whether to maintain or sunset existing code.

Records decisions and documentation. Use when making architectural decisions, changing public APIs, shipping features, or when you need to record context that future engineers and agents will need to understand the codebase.

Builds production-quality UIs. Use when building or modifying user-facing interfaces. Use when creating components, implementing layouts, managing state, or when the output needs to look and feel production-quality rather than AI-generated.

Structures git workflow practices. Use when making any code change. Use when committing, branching, resolving conflicts, or when you need to organize work across multiple parallel streams.

Analyzes project architecture and generates ESLint rules that encode team conventions — giving the agent and developers immediate feedback when code drifts from established patterns.

Refines ideas iteratively. Refine ideas through structured divergent and convergent thinking. Use "idea-refine" or "ideate" to trigger.

Delivers changes incrementally. Use when implementing any feature or change that touches more than one file. Use when you're about to write a large amount of code at once, or when a task feels too big to land in one step.

Optimizes application performance. Use when performance requirements exist, when you suspect performance regressions, or when Core Web Vitals or load times need improvement. Use when profiling reveals bottlenecks that need fixing.

Breaks work into ordered tasks. Use when you have a spec or clear requirements and need to break work into implementable tasks. Use when a task feels too large to start, when you need to estimate scope, or when parallel work is possible.

Hardens code against vulnerabilities. Use when handling user input, authentication, data storage, or external integrations. Use when building any feature that accepts untrusted data, manages user sessions, or interacts with third-party services.

Prepares production launches. Use when preparing to deploy to production. Use when you need a pre-launch checklist, when setting up monitoring, when planning a staged rollout, or when you need a rollback strategy.

Creates specs before coding. Use when starting a new project, feature, or significant change and no specification exists yet. Use when requirements are unclear, ambiguous, or only exist as a vague idea.

Drives development with tests. Use when implementing any logic, fixing any bug, or changing any behavior. Use when you need to prove that code works, when a bug report arrives, or when you're about to modify existing functionality.

Refactors an existing test suite to match behavioral naming, correct folder structure, and internal quality standards — without breaking passing tests.

Discovers and invokes agent skills. Use when starting a session or when you need to discover which skill applies to the current task. This is the meta-skill that governs how all other skills are discovered and invoked.

Generate or update the Project Master Context document (project_context.md) from a Design Doc or Intake Brief. Use whenever the user wants to create, update, or iterate a project context or master context. Triggers: "create the project context", "generate project_context.md", "build the master context", "bootstrap the project", "update the project context", "process this design doc", "process this intake brief". Also trigger when the user uploads a Design Doc PDF or Intake Brief docx and asks to extract or structure the project context.

Generates and iterates the domain model document (docs/domain_model.md) for a project. Use when the user says: "generate the domain model", "create the domain model", "domain model", "update the domain model", "model the domain of [feature]", "genera el domain model", "modelo de dominio", or any variation requesting a domain model, entity model, or data model document.

Generates a complete Functional Spec document (Spec Funcional) from a design document (PDF, DOCX, or MD). Use this skill whenever the user wants to create, draft, or generate a functional specification, functional spec, spec funcional, or "spec" from a design doc, design document, epic design, wireframe description, or any written product/feature description. Also trigger when the user says things like "generate the spec from this doc", "create a functional spec", "write the spec for this feature", "turn this design into a spec", "dame el spec funcional", "genera el spec de esta épica", or any variation. If the user uploads a PDF, DOCX, or MD file alongside a request to produce a spec or functional document, always use this skill.

Generates a Technical Design Document (TDD) from a Spec Funcional and domain document. Use whenever the user wants to create a technical design doc, TDD, design doc, architecture doc, "diseño técnico", or "documento de diseño". Trigger phrases: "generate a technical design", "write a design doc", "create a TDD", "document the technical solution", "genera el diseño técnico", "crea el TDD". Requires a Spec Funcional as input — do not generate a TDD without one. Covers: problem statement, solution with ASCII flows and diagrams, component architecture, data model, API design, security, and integrations. NOT a functional spec — use skill-1 instead.

Generates individual Epic documents from a Spec Funcional and optionally a TDD. Use this skill whenever the user wants to generate epics, break down a feature into epics, "genera las épicas", "crea los documentos de épica", "break this spec into epics", "generate epic docs from the design", or has just finished a Spec Funcional or TDD and wants to continue into epic generation. Outputs .md by default, .docx on request.

Generate engineering Story files (.md) from an epic. Triggers: "write story S-XXX", "create story", "generate stories for this epic", "expand S-XXX", "next story", or any request to produce a story document when an epic is present.

Sync epics and user stories from the local repository to a Lark Base via the Avila Tools API. Use this skill whenever the user wants to push backlog items (epics, stories, HUs) to Lark, sync the repo backlog to Lark Base, or load epics into the project management base. Trigger phrases include: "sync to Lark", "push epic to Lark", "load backlog to Lark Base", "carga la épica al Lark", "sincroniza el backlog", "push E-002 to Lark". This skill reads .md files from the local repo (it does NOT clone anything), parses them, translates content to Spanish, and POSTs to the Lark Base endpoint.

1 hook across 1 event