eugenelim

@eugenelim source repo

147 skills
0 followers
4 hours ago last updated

▌
Example Skill 2 · eugenelim
Demonstrate the standard skill layout. Triggers on: run example, show example skill output. Near-miss: requesting a demo or test of any skill (route those to the specific skill).

0
installs
▌
Bug Fix · eugenelim bundle
Use this skill when the user wants to diagnose or fix a deviation between current and intended behavior in existing code -- including requests to find the root cause, explain a CI-only failure, investigate intermittent or flaky behavior, or contain and diagnose a production incident. Triggers on "fix bug", "diagnose and fix", "find the root cause", "why does this fail", "investigate this regression", and "this is broken". Do NOT use for new features, behavior-preserving refactors, postmortems, or skill maintenance; use the repository's planning workflow instead.

0
installs
▌
New Adr · eugenelim bundle
Use this skill when the user asks to create, write, draft, or open a new ADR (architecture decision record). Triggers on phrases like "new ADR", "write an ADR for...", "record this decision", "let's ADR this". Do NOT use for RFCs (use `new-rfc`) or feature specs (use `new-spec`).

0
installs
▌
New Rfc · eugenelim bundle
Use this skill when the user asks to propose, draft, or open an RFC, update the rules, amend the charter, change our principles, or change the convention for something; also use it for follow-on RFC artifacts after acceptance. Triggers on "RFC", "propose a change to...", "let's get input on...", "draft a proposal", "create the follow-on specs for RFC-NNNN", "generate ADRs for the accepted RFC", and "implement the follow-on work from an RFC". Do NOT use for a settled architectural decision (use `new-adr`, including a superseding ADR), or for a standalone settled feature spec (use `new-spec`).

0
installs
▌
New Spec · eugenelim bundle
Use this skill when the user wants to start a new feature with a spec, or wants to write a spec for something they're about to build. Triggers on "new spec", "write a spec for X", "let's spec this out", "start a feature for...". Spec-driven development; the spec drives implementation. Do NOT use for cross-cutting proposals (use `new-rfc`) or recording decisions (use `new-adr`).

0
installs
▌
Work Loop · eugenelim bundle
Use when implementing or resuming a non-trivial repository change: a feature, behavior-changing fix, refactor, migration, framework or dependency upgrade, schema or API change, performance work, infrastructure or build-system change, reversion, or an existing build spec under `docs/specs/`. Also use for bare continuation commands ('resume', 'continue', 'keep going', 'pick up where I left off', 'let's get going') when conversation or workspace context identifies active build work. Do not use for shaping, research, strategy, product planning, design exploration, monitoring or status-only work, review-only, explanation-only, specification-authoring-only, spike-only or throwaway exploration, or trivial edits that are cosmetic, tightly local, behavior-preserving, and have obvious verification.

0
installs
▌
Close Work · eugenelim bundle
Use when completed, abandoned, or superseded delivery work needs closeout, durable-context verification, initiative reconciliation, pause handling, or a safe immediate-disposition preview.

0
installs
▌
Rfc Status · eugenelim bundle
Surface the current RFC landscape at a glance — how many RFCs are in each lifecycle state, which are active, and how many findings are waiting in the candidate register. Triggers on 'rfc status', 'show rfcs', 'what rfcs are open', 'rfc dashboard', 'how many rfcs', 'rfc candidates', 'rfc report', or any request for an overview of the RFC landscape. Read-only: never creates or modifies RFC files.

0
installs
▌
Compile Okf · eugenelim bundle
Use when a catalogue maintainer needs to compile declared OKF authoring bundles into generated router and reviewed procedure Skills, or check that committed generated output is current.

0
installs
▌
Work Intake · eugenelim bundle
Use for a raw or ambiguous work request, source acquisition or refresh, generic intake-safety handling, or an older compatibility alias. Explicit status, artifact, skill, product-shaping, architecture-design, and defect requests route directly to their owners.

0
installs
▌
Author Brief · eugenelim bundle
Deprecated compatibility alias for author-delivery-brief create. Use only when an older caller explicitly invokes author-brief.

0
installs
▌
Capture Work · eugenelim bundle
Use this compatibility skill when the user asks to capture, queue, remember, or add follow-up work for later. Prefer work-intake for new usage; this name remains active only to route older capture-work prompts to the canonical intake surface.

0
installs
▌
Init Project · eugenelim bundle
Use this skill to turn an idea into a structured new repo. It runs a trigger gate (throwaways and single scripts skip it), a value gate over fed-in discovery, records a foundation (an ADR plus a reference.md golden path), authors a walking-skeleton spec via new-spec and hands the build to work-loop, then hands off to the normal build loop. Triggers on "start a new project", "greenfield init", "idea to repo", "bootstrap a new codebase". Do NOT use inside an existing repo (use adapt-to-project) or to author one feature (use new-spec).

0
installs
▌
Intake Intent · eugenelim bundle
Use when a raw or admitted request should become a minimum repository intent for later shaping, without creating an RFC, delivery brief, spec, or executable queue item.

0
installs
▌
Receive Brief · eugenelim bundle
Deprecated compatibility alias for author-delivery-brief continue. Use only when an older caller explicitly invokes receive-brief.

0
installs
▌
Figma · eugenelim bundle
Read and inspect Figma files (Cloud) via the REST API. Supports fetching files / specific nodes / file metadata / version history / comments, rendering frames to PNG/SVG/JPG/PDF, posting comments (file-level or pinned to a node), converting FigJam connector graphs to Mermaid, and best-effort reads of design tokens (variables) and dev resources where the token's plan allows. Use when the user wants to read, render, comment on, or extract structure from a Figma file. Does NOT modify design content -- that requires the Figma Plugin API, not REST.

0
installs
▌
Assimilate Repo · eugenelim bundle
Use to survey a whole external repo or catalogue (local path or URL) for ingestion candidates and produce a reviewable RFC of per-candidate verdicts (assimilate, reject, or needs-new-pack), resumable across sessions and git worktrees via a ledger. Triggers on "survey this repo for skills we can adopt", "inventory this catalogue", "what can we assimilate from <repo>", "re-sync from <upstream>". Do NOT use for a single known unit (use assimilate-primitive) or to scaffold a proposed pack (use propose-catalogue-pack).

0
installs
▌
Adapt To Project · eugenelim bundle
Use this skill to diagnose and improve an adopter repository's agent guidance or to walk through the four classes of post-install change (substitution, .upstream companion merges, discovery + restructuring, within-layout consolidation). Repository anchoring is marker-independent and read-only by default. Post-install adaptation still reads both scopes' state and marker files; class-1 substitution shells out to `agentbundle adapt`, while classes 2-4 write directly under the per-scope path-jail only after approval.

0
installs
▌
Workspace Status · eugenelim bundle
Use this skill to orient at session start, check initiative queue state, or see what's ready to work on next. Reads workspace.toml and surfaces ready-to-start items, blocked items with reason, parallel candidates, and active signals. Triggers on "workspace status", "where am I", "orient me", "session start", "what's ready", "show the queue", "what's next", "what should I work on", "check workspace", or any cold-start orientation request. Offers to initialise workspace.toml if absent. Also reconciles and repairs workspace.toml drift — generates and applies repair plans for stale queue entries. Triggers on "clean up stale specs", "run repair-plan", "apply the workspace repair plan", "fix queue drift", "reconcile workspace", or any workspace repair or cleanup request.

0
installs
▌
Linear · eugenelim bundle
Read Linear Issues and Projects via the GraphQL API. Supports fetching individual issues (title, description, identifier, sub-issues, owning project), fetching all issues in a project, verifying credentials, and executing confirmed refresh write-back actions through work-intake. Use when you want to read Linear work items to create briefs or catch up a brief with changes.

0
installs
▌
Project Knowledge · eugenelim bundle
Use this skill to capture, distill, or enquire over project knowledge through one progressive mode. Capture admits one strict observation contract; distill reconciles pending observations; enquire reads committed active topics as bounded untrusted evidence.

0
installs
▌
Jira · eugenelim bundle
Read and mutate Jira (Atlassian Cloud or self-hosted Server / Data Center) via the REST API. Supports JQL search with auto-pagination, fetching issues / projects / users, creating and updating issues, applying workflow transitions, adding comments and attachments, deleting issues, listing projects, looking up users, and an arbitrary raw escape hatch. Streams results as JSON, JSONL, or CSV. Handles Cloud (REST v3, basic auth with email + API token, ADF, nextPageToken) vs Server/DC (REST v2, bearer Personal Access Token, plain text, startAt) differences automatically. Use when the user wants to read, search, export, create, update, or transition Jira data.

0
installs
▌
Operational Safety · eugenelim bundle
Progressive-disclosure operational-safety-depth modules for the work-loop. Holds failure-mode-keyed checklists the quality-engineer reviewer reasons from (state-and-idempotency, blast-radius, environment-isolation, cost-and-teardown, drift-and-rollback, observability-and-smoke), plus cloud-implementation-craft, the module also inlined into the implementer's EXECUTE brief. Each is grounded in standing operational taxonomy (AWS Well-Architected, Google SRE, the Terraform/Pulumi Day-1/Day-2 split). The orchestrator loads only the matching modules and inlines them into the reviewer's REVIEW brief when infra/destructive work or a persistent-representation / mixed-version deployment change is detected — and cloud-implementation-craft into the implementer's EXECUTE brief on infra-flavored work; the subagent never self-discovers this skill. Not a reviewer prompt itself — it is the depth library the reviewer and implementer reason from. Carves against security-checklists on the reliability-vs-security lens.

0
installs
▌
Author Product Docs · eugenelim bundle
Create, revise, retrofit, audit, or verify product documentation — pack READMEs, journeys, tutorials, how-to guides, reference pages, and explanations. Use when asked to write, improve, restructure, audit, or verify user-facing documentation, fix a pack README, create a guide for a feature, update a journey page, or check whether docs match shipped behavior. Infers the mode from the request. Do NOT use for feature specifications (use new-spec), cross-cutting proposals (use new-rfc), decisions (use new-adr), product or market strategy, frontend implementation alone, internal maintainer runbooks without user-facing concern, or arbitrary prose editing with no documentation purpose.

0
installs
▌
Security Checklists · eugenelim bundle
Progressive-disclosure security-depth modules for the security-reviewer. Holds boundary-keyed checklists (access-control, authn-session, injection, path-and-file, secrets-and-crypto, outbound-ssrf, supply-chain, config-misconfig, exceptional-conditions, llm-agent, agentic-skills) as references/, each anchored on a current standard (OWASP Top 10:2025, ASVS 5.0, API Security Top 10:2023, Proactive Controls 2024, CWE Top 25, OWASP LLM Top 10:2025, OWASP Top 10 for Agentic Applications:2026, OWASP Agentic Skills Top 10 v1.0 (AST01–AST10)). The work-loop's orchestrator loads only the boundary-matching modules and inlines them into the security-reviewer's brief; the subagent never self-discovers this skill. Not a reviewer prompt itself — it is the depth library the reviewer reasons from.

0
installs
▌
Assimilate Primitive · eugenelim bundle
Use to bring a single external agent primitive — one skill, subagent, hook, or command (or a small connected bundle) — from a local path or URL into this catalogue. Fetches it, diagnoses the destination pack and lifecycle from the local charter, and migrates it to pack convention, or rejects it with a reason. Triggers on "assimilate this skill from <path/url>", "bring in this agent", "adopt this hook into a pack". Do NOT use to survey a whole repo (use assimilate-repo) or to justify a new pack (use propose-catalogue-pack).

0
installs
▌
Contract Acquisition · eugenelim bundle
Acquire a platform's or library's real contract from its own toolchain oracles before authoring against an unfamiliar one — infrastructure, a CLI invocation, code on a managed runtime, or code against an unfamiliar framework or third-party library whose contract you don't hold. Triggers on "deploy to", "write the Terraform / Pulumi / CDK for", "provision", "what's the right resource shape", "why does this apply fail", "what's the signature / does this still exist in this version", "why does this library call raise". Runs a tiered, tool-keyed protocol — detect the stack or library + version, run the toolchain's validate / plan / synth or the type-checker / compiler + API-surface oracle, consult a curated skill, retrieve versioned docs, then a runtime probe — declares its oracle tier and degrades honestly to the probe when no strong static oracle exists. Do NOT use for code whose contract you already hold (use work-loop directly), nor to review a finished diff (rides quality-engineer).

0
installs
▌
Author Delivery Brief · eugenelim bundle
Use with an explicit create or continue mode to author a Draft delivery brief from a coherent multi-slice or cross-repository outcome, or to review an existing repository brief for Ready and select confirmed delivery slices.

0
installs
▌
Propose Catalogue Pack · eugenelim bundle
Use to justify and scaffold a NEW pack area for this catalogue — test that it is additive and fits the target catalogue's declared coverage model and applicable Charter admission path, then scaffold the pack shell and emit an RFC with a per-primitive inventory, or reject it as non-additive. Triggers on "should we add a pack for <area>", "propose a new pack", "justify a <vendor/domain> pack". Do NOT use to ingest units (use assimilate-primitive or assimilate-repo).

0
installs
▌
Jira Align · eugenelim bundle
Read and mutate Jira Align (Atlassian Cloud or self-hosted/on-prem) via the REST API 2.0. Supports fetching individual records (epics, features, stories, capabilities, themes, portfolios, programs, teams, users, etc.), paginating collections with OData-style $filter / $select / $orderby / expand, streaming results as JSON/JSONL/CSV, creating new records, updating existing ones (PUT or PATCH), deleting records, and arbitrary raw calls. Use when the user wants to read, search, export, create, or update Jira Align data.

0
installs
▌
Github Refresh · eugenelim bundle
Reviewed refresh and confirmed GitHub coordination write-back processor for tracker-origin artifacts.

0
installs
▌
Example Skill · eugenelim bundle
Demonstrate the standard skill layout. Triggers on: run example, show example skill output. Near-miss: requesting a demo or test of any skill (route those to the specific skill).

0
installs
▌
Flow Metrics · eugenelim bundle
Use this skill when the user asks for DORA / Flow Framework metrics over a Jira scope -- "what's our cycle time this quarter for PROJ", "give me throughput and WIP for the Foo team", "compare flow efficiency before/after the AI-pairing rollout via a cohort split", "rollup flow metrics across program 42". Computes cycle time, lead time, throughput, WIP, flow load, rework rate, flow efficiency, flow distribution, and defect ratio from Jira changelogs (optionally joined with Jira Align for program / portfolio scope). Read-only -- never transitions, comments, creates, updates, or deletes Jira data. Do NOT use for live-dashboard streaming, deployment-event metrics (Change Failure Rate / MTTR proper), or anything requiring a tracker that isn't Jira.

0
installs
▌
Jira Refresh · eugenelim bundle
Reviewed refresh and confirmed Jira coordination write-back processor for tracker-origin artifacts.

0
installs
▌
API Contract · eugenelim bundle
Use when generating an OpenAPI 3.1 API contract from requirements, user stories, or domain models. Applies a pluggable API standard (Zalando by default) as hard constraints to produce complete, validated YAML specs ready for code gen, test gen, mocks, and SDKs. Activate for tasks involving API design, REST contract authoring, or OpenAPI spec creation.

0
installs
▌
Render Proof · eugenelim bundle
Render a Markdown file as a self-contained, offline HTML proof artifact styled for human review. Use when the user asks to "render this for review", "proof this draft", "give me a proof of this document", "show me this markdown rendered", or "make this readable for a reviewer". Outputs a single HTML file that opens in any browser with no server or network access at view time. Not for slides, presentations, or publication — use markdown-to-html for that. The rendered output uses a muted stone/slate palette deliberately distinct from the publication look.

0
installs
▌
Event Contract · eugenelim bundle
Use when authoring an AsyncAPI event contract from requirements, user stories, or domain models. Applies a pluggable event-design standard (Zalando by default) as hard constraints and composes a swappable message envelope (CloudEvents by default) to produce a complete, validated AsyncAPI document for an event stream you produce or own. Activate for event-driven API design, event/message contract authoring, or AsyncAPI spec creation. Author only when the feature produces or owns the event type, not when it merely consumes one.

0
installs
▌
Source Map · eugenelim bundle
Curate the authoritative sources for a topic before research begins. Surveys adjacent material to discover voices rather than asking the LLM directly who's authoritative — STORM's finding is that direct question-asking does not work well for source discovery. Produces `<topic-slug>-sources.md` grouping candidates by primacy (`primary` / `secondary` / `tertiary`). When invoked downstream of `/identify-perspectives`, groups sources by camp; in standalone invocations, skips the camp-grouping step. Depth cues — `quickly`, `top three`, `briefly`, `summary only` for narrow surveys; `comprehensively`, `exhaustively`, `in depth`, `extensive` for thorough ones.

0
installs
▌
Linear Brief Sync · eugenelim bundle
Use this compatibility skill when you want to catch up an existing product brief with changes in the linked Linear Issue — "sync the brief with LIN-123", "the Linear issue has been updated, update the brief". It delegates refresh authority, lifecycle checks, and write-back confirmations to the configured `work-intake` Linear refresh processor while preserving the old trigger language.

0
installs
▌
Run Swot · eugenelim bundle
Use when a strategist needs a structured situation synthesis before committing to a strategic direction. Triggers on "run a SWOT", "I need to understand our position", "situation synthesis before setting strategy", "what are our strengths and weaknesses", "map out opportunities and threats". Produces a committed SWOT artifact. Do NOT use as a substitute for market data — SWOT organizes what you know; it does not generate evidence you don't have.

0
installs
▌
Security Checklists Reference · eugenelim bundle
Route into the compiled OKF bundle `security-checklists` using generated indexes.

0
installs
▌
Architect Assess · eugenelim bundle
Use when the user wants to understand, assess, harden, optimize, scale, modernize, rationalize, replace, or plan action for the architecture that exists in a repository or implemented system. Routes the generic request "assess architecture and provide an action plan" here. Builds a correctable current-state model, evidence coverage, an attention heat map, bounded hotspot drill-downs, findings, and dependency-aware action waves. Do NOT use for a future-state design choice (architect-design), a diagram as the main ask (architect-diagram), or critique of a supplied artifact (architect-review).

0
installs
▌
Architect Design · eugenelim bundle
Use when the user is framing a problem, weighing a technical choice, or designing a system or integration without a diagram as the headline ask. Triggers on "how should we", "we need to", "what's the right way to build X", tech-selection, integration design, NFR trade-offs. Shapes a one-page concept first, then produces a Google-style design doc (TL;DR, context, goals/non-goals, proposal, alternatives, risks, rollout, open questions), 2-5 pages, with Mermaid inline, and converges it against review. Cloud well-architected by construction (AWS/Azure/GCP and primitives providers like Hetzner). Do NOT use when the ask is a diagram (use `architect-diagram`) or a critique (use `architect-review`).

0
installs
▌
Architect Review · eugenelim bundle
Use when the user supplies an architecture artifact (assessment report, design doc, diagram, RFC, ADR) and asks for critique. Triggers on "review this", "what's wrong with", "is this any good", or any artifact-shaped paste with a question attached. Produces a verdict (SHIP IT / SHIP WITH CHANGES / MAJOR REWRITE / WRONG ARTIFACT), executive summary, severity-tagged findings, and a closing "what's working" section. Also runs a well-architected / lens review mode (concern + workload-class lenses incl. GenAI/agentic) emitting a risk register with mechanical/judgment-tagged findings. Renders inline by default; saves only on an explicit user request naming the destination. Do NOT assess a repository, produce an artifact, or redesign the system.

0
installs
▌
Jira Defect Flow · eugenelim bundle
Use this skill when the user points at a Jira defect and asks you to handle it end-to-end -- "fix PROJ-123", "work this bug ticket", "diagnose and ship a fix for this defect". The skill pulls the ticket via the `jira` skill, hands the actual fix to the `bug-fix` skill (reproduction-first, root-cause, minimum-diff, regression-test), opens a PR whose body links back to Jira, and comments + transitions the ticket. By default it stops at PR-opened; runs a dev-deploy step only if the consumer repo provides one. Do NOT use for stories, tasks, or feature work -- those go through `new-spec`.

0
installs
▌
Jira Team Status · eugenelim bundle
Team backlog status for sprint, stand-up, and orientation — what the team can pick up, what is ready, blocked, in progress, unassigned, stale, or needs story work. Triggers on "show me the team backlog", "what can the team pick up", "what is ready", "what is blocked", "what is unassigned", "sprint status", "stand-up summary", "stale team work". Applies the five-question bar only when explicitly asked for agent-ready or one-PR work. Always start read-only; disclose scope and completeness. Do NOT use to improve weak stories (use jira-story-triage), create an issue (use jira), apply approved updates (use jira), turn an epic into specs (use jira-brief-intake), fix a defect end-to-end (use jira-defect-flow), or for the local workspace queue (use workspace-status).

0
installs
▌
Msg To Markdown · eugenelim bundle
Convert Outlook .msg and MIME .eml email files to Markdown with a versioned output contract, preserving headers (From, To, CC, BCC, Date, Importance), the body (HTML reduced to Markdown, or plain text), and an attachments table. Use when the user wants to convert, read, or process a .msg or .eml email into Markdown, or extract its attachments.

0
installs
▌
Github Brief Intake · eugenelim bundle
Use when GitHub work should enter the repository work-intake route, including an Issue, Milestone, view, or cross-repository selection.

0
installs
▌
Generate Iac · eugenelim bundle
Use this skill to author governed, best-practice Terraform/OpenTofu infrastructure from a plain-language intent. Triggers on "provision X", "create Terraform for", "generate IaC for", "set up cloud resources", "write Terraform for", "scaffold infrastructure". Stops at a digest-pinned `terraform plan` (G4 handoff); never runs `apply`. Governance-first — resolves the decision-record surface before any code.

0
installs
▌
Linear Brief Intake · eugenelim bundle
Use when Linear work should enter the repository work-intake route, including an Issue, sub-issues, a Project, Cycle, view, or cross-repository selection.

0
installs
▌
Architect Diagram · eugenelim bundle
Use when the user asks for a diagram of a system, integration, flow, state, data model, deployment topology, roadmap, prioritization matrix, or decomposition. Triggers on "show me", "draw", "diagram of", or artifact-shaped nouns like "sequence", "C4 Container view", "state machine", "roadmap", "2×2", "mind map", "branching strategy", "gantt", "sprint plan". Produces Mermaid diagrams (flowchart, sequenceDiagram, C4, stateDiagram-v2, erDiagram, gitGraph, gantt, plus timeline, quadrantChart, and mindmap for roadmaps, prioritization, and hierarchical decomposition) routed by intent. Cloud-aware (AWS, Azure, GCP, and primitives providers like Hetzner) and agentic-platform-aware (Bedrock AgentCore, AI Foundry, Vertex Agent Engine). Do NOT use for full design-doc drafting (use `architect-design`), critique (use `architect-review`), or comparison tables (use plain Markdown).

0
installs
▌
Jira Brief Intake · eugenelim bundle
Use when Jira work should enter the repository work-intake route, whether the selection is one issue, an epic, a board, a sprint, or JQL.

0
installs
▌
Jira Story Triage · eugenelim bundle
Review Jira work items for readiness and improve weak stories — it explains why each item is not ready (which question failed and the specific gap), identifies unresolved human questions, drafts proposed rewrites and acceptance criteria, and writes to Jira only after you approve the exact payload; read-only until then. Triggers on "which stories are not ready", "which stories need more detail", "improve these weak stories", "make these tickets actionable", "draft better acceptance criteria", "apply the story-readiness bar", "explain why these items are not ready", "prepare Jira story improvements without writing". Do NOT use for a read-only team status snapshot or what to pick up next / blocked / unassigned / in progress / stand-up (use jira-team-status), to create an issue (use jira), to apply approved updates to named issues (use jira), to turn an epic into specs (use jira-brief-intake), or to fix a defect end-to-end (use jira-defect-flow).

0
installs
▌
File To Markdown · eugenelim bundle
Convert documents and images to Markdown for AI context layers. Documents (PDF, DOCX, XLSX, PPTX, HTML, EPUB, CSV/TSV, OpenDocument, .eml) go through `scripts/convert.py`, which extracts at a no-ML Tier-0 floor (pure-Python / stdlib parsers) and falls through to Docling (Tier 2) only for .xls and images; images go through a two-pass sliding-window vision pipeline whose tiling and reconciliation are deterministic (`scripts/split_image.py` and `scripts/reconcile.py`). Every output carries a versioned frontmatter contract (provenance + a quality/confidence signal). The agent's job is the per-tile vision read; tile dedup and ordering are handled by the script.

0
installs
▌
Markdown To DOCX · eugenelim bundle
Fill a branded Word template from a Markdown artifact — turn this Markdown into a Word doc, produce a report, a memo, a statement of work, or a branded .docx. The deterministic script fills the Jinja fill-points a designer placed in the template (front-matter, headings, lists, tables map onto them), so the cover page, styles, headers, and placed logo survive. Use when the user wants a Word document, report, memo, or .docx out of Markdown. Tier-1 on docxtpl (the user installs it; the skill detects it and stops if absent).

0
installs
▌
Markdown To HTML · eugenelim bundle
Convert a Markdown file to a self-contained, styled HTML page (sticky header, sidebar nav, syntax-highlighted code, callout boxes, Mermaid diagrams, print-ready). Use when the user asks to render, convert, or export a `.md` file as a shareable HTML document -- not for slides, presentations, or pitch decks. Rendering is deterministic via `marked` + `highlight.js`; the agent only invokes the script.

0
installs
▌
Markdown To PPTX · eugenelim bundle
Fill a branded PowerPoint template from a Markdown artifact — turn this into slides, build a slide deck or presentation, produce a branded .pptx. The deterministic script inspects the template's layout placeholders and projects your Markdown (front-matter, headings, lists, tables) onto them, so the user's slide master, theme, and placed assets survive. Use when the user wants a PowerPoint, a slide deck, or a presentation out of Markdown. Tier-1 on python-pptx (the user installs it; the skill detects it and stops if absent).

0
installs
▌
Markdown To XLSX · eugenelim bundle
Fill a branded Excel template from a Markdown artifact — export this table to Excel, fill the .xlsx template, produce a spreadsheet or workbook. The deterministic script writes Markdown content into the named ranges and Excel Tables a designer defined (front-matter into single-cell names, a Markdown table into a Table data region), so the workbook's formatting, formulas, and charts survive. Use when the user wants Excel, a spreadsheet, or an .xlsx workbook out of Markdown. Tier-1 on openpyxl (the user installs it; the skill detects it and stops if absent).

0
installs
▌
Mermaid Renderer · eugenelim bundle
Extract ` ```mermaid ` fenced blocks from a Markdown file, render each one to a PNG (or SVG) via the Mermaid CLI (`mmdc`), and write a rewritten Markdown file alongside with each fence replaced by an image reference. Use when the user wants Mermaid diagrams baked into images for downstream tools that don't render Mermaid natively (Confluence, PDF, slides). The agent only invokes the script.

0
installs
▌
Build Outline · eugenelim bundle
Decompose a research question into the sub-questions a thorough answer must address. Builds the outline that `/source-map` then populates and `/desk-research` then synthesises against. Grounded in STORM's outline stage (multi-perspective topic decomposition) and PRISMA's PICO framework (Population, Intervention, Comparison, Outcome — the systematic-review decomposition). Produces `<topic-slug>-outline.md` listing each sub-question with a brief rationale. Depth cues — `quickly`, `top three`, `briefly`, `summary only` for the must-answer few; `comprehensively`, `exhaustively`, `in depth`, `extensive` to chase second-order sub-questions.

0
installs
▌
Desk Research · eugenelim bundle
Evidence-grounded research with selectable depth and discipline. Use for any look-up, find-out, fact-check, or comprehensive investigation, including prior art and best practice surveys. Carries a mode parameter (quick / standard / applied / deep) with `quick` as default — casual phrasings (`look up`, `find out`, `quick check`) stay quick; academic phrasings (`research with citations`, `evidence-grounded`, `go deep`, `comprehensively`) bias standard or deep; practitioner phrasings (`applied patterns for`, `best practice for`, `prior art on`, `grey literature`) bias applied. Quick mode is inline, ≤5 fetches, no artifact. Standard mode produces `<topic-slug>-survey.md` with GRADE-style confidence per finding from peer-reviewed and primary sources. Applied mode produces `<topic-slug>-survey.md` calibrated for practitioner grey literature with a discipline-aware confidence overlay. Deep mode additionally auto-runs `/devils-advocate`, producing `<topic-slug>-counterpoints.md`.

0
installs
▌
User Flow · eugenelim bundle
Use when an approved customer journey needs to become screens, transitions, failure paths, and navigation routes. Produces a complete screen sequence plus one self-contained brief per screen and a whole-flow walk-through. Use `journey-mapping` to understand the journey first, `interaction-design` for behavior within one screen, and `service-blueprint` for backing services. Adoption strategy belongs upstream; appetite and scope belong to `frame-intent`; implementing routes and screens belongs to `frontend-engineering`. Triggers on "turn this account-recovery journey into screens and transitions", "map the error paths across our checkout screens", "create a screen flow and brief for every onboarding screen".

0
installs
▌
Reconcile Iac · eugenelim
Use this skill to audit Terraform/OpenTofu drift, reconcile state, run a pre-change preflight, or check an incoming IaC diff for ADR compliance. Triggers on "reconcile my infrastructure", "check for drift", "drift audit", "what drifted", "before I change X check drift", "is my infra in sync", "adr-check", "does this change comply", "check this diff against our ADRs", "compliance check this IaC change". Never autonomously applies. Shares generate-iac's references and reviewers.

0
installs
▌
New Package · eugenelim bundle
Use this skill when the user wants to scaffold a new package in the monorepo's `packages/` directory. Triggers on "new package", "create a package called...", "add a library for...". Don't use for new top-level directories (those need an RFC) or for new apps (which go in `apps/`, not `packages/`).

0
installs
▌
AI Adoption Report · eugenelim bundle
Use this skill to compare flow-metrics JSON outputs and produce a Markdown comparison report -- "how do our flow metrics now compare to pre-AI?", "within Q4 did AI-tagged tickets behave differently from untagged?", "what does Q4 look like across all teams in the program?". Three modes -- baseline (two windows, one scope), cohort (within-window AI vs control), program (roll up many scopes for one window). Read-only -- consumes flow-metrics JSON files, makes no upstream calls, never invokes flow-metrics / jira / jira-align. Writes only the Markdown report and an optional JSON sidecar.

0
installs
▌
Confluence Crawler · eugenelim bundle
Crawl an authenticated Confluence space (Atlassian Cloud or on-prem Server/Data Center) by page hierarchy and convert each page to clean Markdown with frontmatter. Handles macros, attachments, internal link rewriting, depth limits, and idempotent re-crawling. Use when the user wants to mirror, export, or ingest Confluence content.

0
installs
▌
Jira Align Refresh · eugenelim bundle
Reviewed Jira Align refresh processor with fail-closed unsupported write-back capability.

0
installs
▌
Write Prfaq · eugenelim bundle
Use when a strategist needs to write the press release before the product exists — an altitude-0 forcing function that surfaces what the product must be before any engineering begins. Triggers on "write a PRFAQ", "I need to write the press release before the product", "altitude-0 forcing function", "press release FAQ format", "Amazon PRFAQ". Produces a committed prfaq.md. Do NOT use as a product spec or backlog — PRFAQ is a direction artifact, not an implementation contract.

0
installs
▌
Devils Advocate · eugenelim bundle
Adversarially review a research artifact (`<topic-slug>-survey.md`) or a user-supplied claim. Searches for counter-evidence, names the strongest objections, and routes each to a verdict — either a confidence-rating downgrade or a do-not-resolve verdict for an irreducible tension where both sides are well-evidenced under different conditions. Grounded in ACH (evidence-against column — the discipline that catches premature closure) and GIJN investigative-journalism practice ("what does the other side say"). Auto-invoked by `/desk-research` deep mode against `<topic-slug>-survey.md`; runs standalone against any user-supplied claim. Produces `<topic-slug>-counterpoints.md` linking back to the source artifact. Depth cues — `quickly`, `top three`, `briefly`, `summary only` for the strongest objections; `comprehensively`, `exhaustively`, `in depth`, `extensive` for the full set.

0
installs
▌
Place Bet · eugenelim bundle
Step 5 of the PE six-step shaping sequence — the bet-commitment gate. Reads a diverge-solutions artifact if present (offers to run it first if absent); accepts options from any source; folds in validation-notes when available; emits bet.md with the full betting table anchoring map-capabilities. Do NOT use to generate options (use diverge-solutions or explore-options) or validate assumptions (use de-risk-intent).

0
installs
▌
New Guide · eugenelim bundle
Create or substantially revise user guides, pack pages, and journey pages using Diátaxis plus conversation-first UX. Use when asked to write, simplify, restructure, audit, or modernize tutorials, how-to guides, reference pages, explanations, pack pages, or journey pages so readers can start from a natural-language goal, see what to say, understand what happens next, and reach an outcome without learning internal skill names first. Do NOT use for feature contracts (use `new-spec`), cross-cutting proposals (use `new-rfc`), recording decisions (use `new-adr`), minor single-line edits (normal PR), contributor docs, docstrings, release notes, or blog posts.

0
installs
▌
Confluence Publisher · eugenelim bundle
Publish content to a Confluence page (Atlassian Cloud or Server/Data Center) by creating a new page or updating an existing one. Accepts Markdown (default), raw Confluence storage XHTML, or plain text. Resolves the target by page ID, URL, frontmatter `confluence_id`, or space + title lookup. Handles optimistic-locking 409s with one retry. Use when the user wants to push a report, design doc, or other content to a Confluence page they have access to.

0
installs
▌
Fe Status · eugenelim bundle
Orient skill — read the current surface's evidence manifest, known exceptions, and gate history to return a surface-state summary against the frontend engineering quality floor. Triggers on "what is the frontend quality status of this surface", "show me the latest gate history and known exceptions", "what should we fix before changing this existing page".

0
installs
▌
UX Writing · eugenelim bundle
Use when shaping the actual words a user reads in a product's UI — characterizing the UI copy voice (how the brand register applies to UI states), writing recurring UI-state microcopy (error, empty, button, label), or reviewing copy before it ships. Triggers on "what should this error say", "write the empty-state copy", "name this button", "characterize our product's UI copy voice", "make this microcopy blame-free", "review this copy". Characterizes voice along a few axes, writes each UI state from a blame-free + actionable formula, and runs a content checklist. When a per-screen state matrix from `user-flow` is present, writes copy per screen × state keyed to the matrix; when absent, behaves as today. Do NOT use to frame the intent behind the feature (use `frame-intent`), to make visual or layout design decisions, to write documentation prose (use `new-guide`), or to establish the brand-level copy register (use `tone-of-voice`).

0
installs
▌
Define Slo · eugenelim
Use to author a Service Level Objective (SLO) document for a service in the release-engineering pack. Produces an OpenSLO v1 YAML file committed to `slos/<service>.yaml`, with an error_budget_policy block, that the release-loop's PRR gate reads to resolve the error-budget status field. Triggers on "define SLOs for this service", "author an SLO", "set up error budget tracking", "create a reliability target", "we need an SLO document", "the PRR shows error-budget: not-defined". Do NOT use to generate Prometheus recording rules or alerting rules (toolchain work — the adopter's pipeline does that), to set up ongoing alerting backend routing, or to run the release loop itself.

0
installs
▌
Design Review · eugenelim bundle
Use when someone asks to critique an existing rendered screen, flow, or mockup for usability, quality-floor, clarity, and aesthetic-fit problems. Produces a severity-rated findings list grounded in the actual artifact. Use `creative-direction` to name a new visual direction, `information-architecture` to design hierarchy, and `design-system` to derive tokens. Reviewing product strategy or choosing a bet is upstream strategy work; framing the work belongs to `frame-intent`; reviewing code defects or implementation quality belongs to frontend engineering. Triggers on "review this checkout flow for usability problems", "critique this landing page mockup against our design principles", "what's wrong with this rendered dashboard".

0
installs
▌
Design System · eugenelim bundle
Use when an approved aesthetic direction exists and someone asks how to name and organize semantic tokens, spacing, type, or color scales. Produces a token taxonomy and rationale; it does not implement token values. Use `creative-direction` to establish the vibe, `information-architecture` for page hierarchy, and `design-review` to evaluate an existing surface. Product differentiation belongs to product strategy; framing a design-system initiative belongs to `frame-intent`; implementing tokens or components belongs to `frontend-engineering`. Triggers on "derive a semantic token taxonomy from this aesthetic direction", "organize our spacing, type, and color scales by role", "design the token system without choosing implementation values".

0
installs
▌
Tone Of Voice · eugenelim bundle
Use when a team asks how the brand should sound consistently across channels and surfaces. Produces a brand-register document with named, ranked voice goals and arbitration rules. It is the upstream anchor: `content-design` owns a surface's message and structure, `copy-direction` owns acquisition-surface copy goals, and `ux-writing` owns product UI strings. Organization-level product or content strategy belongs to the strategy packs; shaping a product initiative belongs to `frame-intent`; implementing copy in templates or components belongs to `frontend-engineering`. Triggers on "define how our brand should sound across product and marketing", "name and rank our cross-surface voice goals", "create a brand register for our support, sales, and product copy".

0
installs
▌
Lean Canvas · eugenelim bundle
Use when a product engineer or PM is ready to produce an initiative brief through an adapted Lean Canvas elicitation — after the PE shaping sequence or as a standalone exercise. Triggers on "lean canvas", "initiative brief", "canvas this initiative", "author initiative brief". Do NOT use for a feature-scoped request (use `frame-intent`) or for individual shaping steps (use `frame-situation`, `place-bet`, etc.).

0
installs
▌
Run Bcg Matrix · eugenelim bundle
Use when a strategist needs to assess portfolio position and derive investment priorities across multiple products or business units. Triggers on "run a BCG matrix", "I need to assess portfolio position", "portfolio growth-share analysis", "which products should we invest in or cut", "star cash cow dog question mark". Produces a committed portfolio-position artifact. Do NOT use for single-product strategy — BCG requires at least two offerings to compare relative market share.

0
installs
▌
Compare Hypotheses · eugenelim bundle
Compare competing hypotheses on a decision-shaped question using an ACH-style evidence matrix (hypotheses × evidence-for/against). Dispatches per-hypothesis parallel retrieval on Claude Code (one `evidence-retriever` subagent per hypothesis — the +81% parallelizable-task case from multi-agent research). In decision-pipeline invocations expects upstream `<topic-slug>-perspectives.md` and `<topic-slug>-sources.md`; standalone invocations enumerate hypotheses inline. Produces `<topic-slug>-hypotheses.md` with the matrix and a most-supported ranking. Depth cues — `quickly`, `top three`, `briefly`, `summary only` for the dominant hypotheses; `comprehensively`, `exhaustively`, `in depth`, `extensive` for fringe ones too.

0
installs
▌
Content Design · eugenelim bundle
Use when someone asks what a surface should communicate, to whom, in what form, and in what order before wireframes or final copy. Produces a content brief for acquisition, product, or reference surfaces. It owns message and narrative structure; `tone-of-voice` owns the brand register, `copy-direction` owns acquisition-surface copy goals, and `ux-writing` owns product UI strings. Organization-level content strategy belongs to `define-content-strategy`; feature framing belongs to `frame-intent`; page or content-system implementation belongs to `frontend-engineering`. Triggers on "create a content brief for our onboarding flow", "decide what this pricing page needs to say and in what order", "shape the message hierarchy before we wireframe the help page".

0
installs
▌
Copy Direction · eugenelim bundle
Use when someone asks what the copy on one marketing or acquisition surface should feel like before the lines are written. Produces ranked, grounded copy goals and a `copy-direction.md` record for that surface. `tone-of-voice` owns the cross-surface brand register, `content-design` runs first to decide message and narrative structure, and `ux-writing` owns product UI strings. Product or growth strategy belongs to product strategy; framing the acquisition bet belongs to `frame-intent`; implementing the surface belongs to `frontend-engineering`. Triggers on "name the copy direction for our pricing page before we write it", "what should this onboarding campaign sound like", "set ranked copy goals for this landing page".

0
installs
▌
Frame Domain · eugenelim bundle
Use when grounding a product in the real-world activity it serves and bounding its MVP before any screen, service, or architecture is drawn — at the G1.5 Domain & MVP point of the discovery loop, or standalone. Triggers on "frame the domain", "how is this activity really done", "ground this before we design", "what's in/out of the MVP", "draw the scope boundary", "is this scope creep". Produces two typed artifacts from one research-grounded pass — Domain Framing (real-world-activity grounding + best practice + naive-failure modes, plus a brownfield current-system half) and Scope Boundary (the MVP out-of-scope register). Do NOT use to shape the intent behind the work (use `frame-intent`), to test whether a bet holds (use `de-risk-intent`), or to break an intent down (use `decompose-intent`).

0
installs
▌
Frame Intent · eugenelim bundle
Use when shaping a piece of product work before it becomes a spec — turning an idea, a request, or a strategy into a level-tagged `intent` (an outcome + the opportunity behind it). Triggers on "shape this", "what's the intent here", "frame the problem", "before we build X", "turn this into a brief/PRD". Authors an `intent` at any altitude in the open recognized set — product-vision, product-strategy, capability, or feature — resolves Scale (app ↔ business-unit) at intake, and offers current-state inputs only when brownfield. Do NOT use to test an assumption (use `de-risk-intent`) or to break an intent down (use `decompose-intent`).

0
installs
▌
Run Okr Cascade · eugenelim bundle
Use when a strategist needs to cascade company OKRs to team level and identify strategic gaps for the product-engineering shaping queue. Triggers on "run an OKR cascade", "I need to cascade company OKRs", "align team OKRs to company goals", "identify OKR gaps", "what are we missing to hit our objectives". Produces okr-cascade.md and workspace.toml shaping-queue entries. Do NOT use for per-feature goal-setting — cascade is org-wide alignment, not product backlog prioritization.

0
installs
▌
Release Loop · eugenelim bundle
Use to drive the deployed end-to-end validation outer loop — deploy the integrated whole to an ephemeral environment, run e2e, observe telemetry, feed deployed findings back to work-loop's inner loop, redeploy, and iterate until the deployed whole converges, then stop at the human consent gate for the prod ship. Run by the release-lead agent (a peer of work-loop's supervisor, not a work-loop mode). Triggers on "run the release loop", "deploy the integrated whole and iterate", "ship it to an ephemeral env and run e2e", "iterate the deployed env until it converges", "take this to a prod-ship readiness record". Autonomy is carved by minimum-regret — reversible ⇒ autonomous on ephemeral envs; irreversible ⇒ human. No engine. Do NOT use for the inner local build loop (use work-loop), to author a fidelity-ladder / local-infra-equivalents skill (that is the inner-loop obligation), or to run the live product as a managed service (adopter ops).

0
installs
▌
Jira Align Brief Intake · eugenelim bundle
Use when Jira Align work should enter the repository work-intake route, including one item, a Feature, a program selection, or a cross-repository outcome.

0
installs
▌
Journey Mapping · eugenelim bundle
Use when a team asks what an end user goes through across an experience, from one meaningful outcome to the next. Produces a customer journey map of stages, actions, touchpoints, emotions, pains, and opportunities, adjusted for the relevant platform. Use `service-blueprint` for backing services, `user-flow` to turn the journey into screens, and `process-mapping` for internal operations. Adoption strategy belongs to product strategy; selecting and scoping a bet belongs to product-engineering shaping; implementing journey screens belongs to `frontend-engineering`. Triggers on "map the customer journey from trial signup to first value", "show what a new admin goes through when setting up a workspace", "map the pains and opportunities in our returns experience".

0
installs
▌
Process Mapping · eugenelim bundle
Use when a team asks how an internal business operation works today or should work tomorrow across actors and handoffs. Produces a SIPOC scope, swimlane map, as-is/to-be flow, and pain-and-waste register. Use `journey-mapping` for the customer's experience, `service-blueprint` to connect a journey to backstage support, and `user-flow` for screens. Operating or product strategy belongs upstream; shaping an automation bet belongs to `frame-intent`; implementing workflow software belongs to engineering. Triggers on "map our monthly close process as it works today", "show the handoffs in our supplier invoice process", "design the to-be process for customer refunds".

0
installs
▌
Decision Archaeology · eugenelim bundle
Reconstruct the rationale for a past decision by walking time-ordered artifacts (commits, PRs, design docs, chat logs, internal memos). Self-contained — does not invoke `/source-map` or other research-pack skills, because the source surface is time-ordered and internal, and authority is established by an artifact's place in the history rather than by external curation. Produces `<topic-slug>-archaeology.md` with chronology, the rationale chain, the alternatives that were considered and rejected, and a revival check flagging rejected alternatives whose original rejection rationale no longer holds. Depth cues — `quickly`, `top three`, `briefly`, `summary only` for the main rationale chain; `comprehensively`, `exhaustively`, `in depth`, `extensive` for branch alternatives and dead ends.

0
installs
▌
Workspace Design · eugenelim bundle
Use when someone asks how a productivity, collaboration, or agentic workspace should support sustained professional work across sessions. Produces a workspace-surface specification covering context persistence, collaboration state, ambient attention, interruptions, and session arcs. Use `analytical-design` for dashboards and monitoring views and `marketplace-design` for exchange surfaces. Product strategy is upstream; choosing the appetite and scope belongs to product engineering; implementing the workspace or writing its UI strings belongs to frontend engineering and `ux-writing`. Triggers on "design the session flow for our collaborative editor", "how should this agent workspace preserve context between sessions", "structure interruptions and handoffs in our team workspace".

0
installs
▌
De Risk Intent · eugenelim bundle
Use when an intent is framed and you need to test whether the bet holds before building it out — naming the riskiest assumption, predeclaring a kill condition, and running it under a chosen prototype-approach. Triggers on "de-risk this", "is this assumption true", "what would have to be true", "should we validate or just build it", "test the bet". Routes by reversibility (one-way vs two-way door) and ends in a survive/kill verdict. Do NOT use to author the intent (use `frame-intent`) or to break it down (use `decompose-intent`).

0
installs
▌
Discovery Loop · eugenelim bundle
Use to turn a raw product idea into a ratified, build-ready decision brief — the upstream discovery loop run by the discovery-lead agent. Triggers on "scaffold the product vision for X", "run a discovery for X", "diverge on the product shape then converge to a brief", "take this idea to a decision brief", "resume the X discovery". It diverges across candidate product shapes, converges the chosen one through a research/product/UX/architecture/safety lens roster, pauses at the consent gates (G0 vision, G1.5 altitude/MVP, G2 the "what"), emits a connected hypothesis with validation hooks, and hands off to work-loop at G3 — with no new engine, scheduler, or service. Do NOT use to build a spec (use new-spec → work-loop), to ship one (the release loop), or to author one discovery artifact standalone (use frame-intent / frame-domain / explore-options directly).

0
installs
▌
Credential Setup · eugenelim bundle
Interactive credential setup for skills declaring `metadata.auth` of creds. Walks the user through entering each required key from the skill's `creds-schema.toml` and writes to the highest-available tier (OS keychain on Darwin/Windows; 0600 dotfile floor on Linux). Triggers on "set up credentials", "credential setup", "credential broker setup". This is interactive, user-invoked, do not auto-run.

0
installs
▌
Identify Perspectives · eugenelim bundle
Enumerate the named camps on a contested topic before research begins. Builds the perspective scaffold that `/source-map` and `/compare-hypotheses` consume downstream in the decision pipeline. Grounded in Wikipedia NPOV (neutral point of view — fairly represent significant views) and ACH (competing hypotheses — surface all explanations before evaluating). Produces `<topic-slug>-perspectives.md` listing each camp's name, its core claim, and representative voices, plus a tension map recording which disagreements are irreducible (both sides right under different conditions) and what a forced resolution would destroy. Depth cues — `quickly`, `top three`, `briefly` for the dominant few; `comprehensively`, `exhaustively`, `in depth`, `extensive` for fringe and dissenting positions too.

0
installs
▌
Analytical Design · eugenelim bundle
Use when someone asks how a dashboard, report, or monitoring view should help a user understand data and act. Produces domain-model-first information architecture and a widget hierarchy for the analytical surface, not individual chart implementations. Use `interaction-design` for component behavior, `conversion-design` for marketing surfaces, and `workspace-design` for sustained-work tools. Metric and outcome strategy belongs upstream; shaping the analytics product belongs to `frame-intent`; implementing charts and data bindings belongs to frontend engineering. Triggers on "design a dashboard that helps on-call engineers spot and act on service degradation", "structure this sales report around the questions leaders need answered", "define the widget hierarchy for our monitoring view".

0
installs
▌
Conversion Design · eugenelim bundle
Use when someone asks how to structure a landing page, product homepage, pricing page, or acquisition flow so a qualified visitor understands the offer and can act. Produces information architecture and structural specifications for a conversion surface. Use `content-design` for its message hierarchy and `copy-direction` for its copy goals; use `user-flow` and `interaction-design` for product UI. Go-to-market strategy belongs upstream; shaping the acquisition initiative belongs to `frame-intent`; writing final copy or building the page is not this skill's job. Triggers on "structure our pricing page to turn qualified visitors into trials", "design the conversion flow for our product homepage", "spec the hero and scroll story for this landing page".

0
installs
▌
Design Principles · eugenelim bundle
Use when a design team asks for durable rules that turn journey evidence and opportunity pains into consistent decisions across sprints. Produces 3–5 named design principles, each with rationale and an arbitration test. Use `creative-direction` for visual goals, `design-system` for token taxonomy, and `design-review` to evaluate existing work. Target segments and product positioning belong to product strategy; choosing and scoping a bet belongs to product engineering; encoding rules in components belongs to frontend engineering. Triggers on "turn these journey pains into design principles", "give us rules to settle recurring design debates", "what principles should guide this product".

0
installs
▌
Experience Status · eugenelim bundle
Use when someone asks where the current experience-design thread stands, which design artifacts exist, what is missing, or which design skill comes next. Reads the configured design output and returns a read-only orientation; it never writes files or performs the missing design work. Product or portfolio status belongs to product strategy, prioritizing and shaping the next feature belongs to product engineering, and implementation or build status belongs to frontend engineering. Triggers on "where are we with the design", "what experience artifacts do we have", "what's next in the design".

0
installs

147 published skills · page 1 of 2