dork-labs
OrganizationIntelligence doesn't scale. Coordination does. Scheduling, messaging, and agent discovery for Claude Code.
Categories
Indexed Skills (32)
designing-frontend
Guides design thinking and decision-making using the Calm Tech design language. Use when planning UI, reviewing designs, or making design decisions. For implementation details, see styling-with-tailwind-shadcn.
opensrc
Fetch dependency source code to give AI agents deeper implementation context. Use when the agent needs to understand how a library works internally, read source code for a package, fetch implementation details for a dependency, or explore how an npm/PyPI/crates.io package is built. Triggers include "fetch source for", "read the source of", "how does X work internally", "get the implementation of", "opensrc path", or any task requiring access to dependency source code beyond types and docs.
visual-companion
Browser-based visual companion for showing mockups, diagrams, comparisons, and interactive options. Use when the user would understand something better by seeing it than reading it.
adding-config-fields
Patterns for adding, renaming, removing, or retyping fields in DorkOS user config. Use when editing UserConfigSchema, MarketplacesFileSchema, or any conf-backed store — walks the Zod field → defaults → conf migration → docs → test lifecycle end-to-end.
executing-specs
Orchestrates parallel implementation of decomposed specifications with incremental progress tracking. Use when running /spec:execute.
managing-specs
Canonical rules for spec manifest management — statuses, transitions, and the manifest-ops script. Auto-loads when working with spec files.
upgrading-runtime-dependencies
Guides strategic analysis of agent runtime dependency upgrades — changelog categorization, codebase impact assessment, and feature adoption decisions. Use when upgrading SDK-level dependencies that sit behind an abstraction boundary.
browser-testing
Methodology for writing and maintaining DorkOS browser tests
debugging-systematically
Guides systematic debugging methodology and troubleshooting approaches. Use when investigating bugs, tracing issues, or teaching debugging patterns.
ideating-features
Turns a feature brief, rough notes, or an existing partial design into a structured ideation artifact and next-step plan. Use when the user wants to explore a feature, shape requirements, or replace the legacy `/ideate` workflow.
implementing-specifications
Implements a validated specification, keeps execution progress durable, and advances linked project work cleanly. Use when the user wants to execute a spec or replace the legacy `/spec:execute` workflow.
organizing-fsd-architecture
Guides organization of code using Feature-Sliced Design (FSD) architecture. Use when structuring projects, creating new features, determining file and layer placement, or reviewing architectural decisions. Also monitors codebase size and proactively suggests structural improvements.
running-product-loop
Reviews the current Linear product loop, recommends the most important next action, and optionally executes it. Use when asked to assess project status, decide what to do next, audit loop health, or work a specific Linear issue directly.
syncing-agent-skills
Keeps skill definitions aligned between Claude Code and Codex. Use when creating, migrating, renaming, or updating skills that must work across `.claude/skills` and `.agents/skills`, or when auditing drift between the two systems.
verification-before-completion
Use when about to claim work is complete, fixed, or passing, before committing or creating PRs - requires running verification commands and confirming output before making any success claims; evidence before assertions always
writing-adrs
Guides writing concise, effective Architecture Decision Records. Use when creating ADRs, extracting decisions from specs, or reviewing ADR quality.
writing-changelogs
Writes human-friendly changelog entries and release notes. Use when populating changelog, preparing releases, or reviewing release notes quality.
writing-developer-guides
Structures developer guides for optimal AI agent and human consumption. Use when creating or updating files in contributing/, or when documentation needs to support autonomous coding agents.
clarifying-requirements
Analyzes user prompts for gaps, ambiguities, and unstated assumptions, then asks clarifying questions before work begins. Use when requests are vague, lack acceptance criteria, or have hidden complexity.
linear-loop
Loop methodology for Linear — issue taxonomy, triage framework, spec workflow bridge, and template routing for /pm and /linear:* commands. Use when working with Linear issues or running the product loop.
maintaining-dev-playground
Keeps the Dev Playground current with the application. Use when editing UI components in apps/client/src/ — assesses playground candidacy, checks existing playground coverage, and guides adding or updating showcases. Also use when directly editing files in apps/client/src/dev/, building new widgets or features, or when the user mentions the dev playground, component showcase, or visual testing. Proactively evaluate whether edited components belong in the playground even if the user doesn't ask.
marketplace-dev
Develop, validate, and publish DorkOS marketplace packages — agents, plugins, skill-packs, and adapters. Use when creating marketplace items, working in the dork-labs/marketplace repo, or helping users build packages for the personal marketplace.
orchestrating-parallel-work
Orchestrates parallel execution of AI agents with dependency analysis and batch scheduling. Use when coordinating multiple concurrent tasks, optimizing task ordering, or when multiple independent agents would benefit the workflow.
reading-session-transcripts
Resolves DorkOS session URLs to JSONL transcript files on disk and reads them. Use when the user shares a session URL, mentions "read this transcript", "read this chat", or references a DorkOS session they want analyzed.
receiving-code-review
Use when receiving code review feedback, before implementing suggestions, especially if feedback seems unclear or technically questionable - requires technical rigor and verification, not performative agreement or blind implementation
requesting-code-review
Guides dispatching a code-reviewer subagent to verify work before proceeding. Use when completing tasks, implementing major features, or before merging to verify work meets requirements.
styling-with-tailwind-shadcn
Implements the Calm Tech design system using Tailwind CSS v4 and Shadcn UI. Use when writing styles, building components, or theming. For design decisions, see designing-frontend.
test-driven-development
Use when implementing any feature or bugfix, before writing implementation code
closing-linear-loop
Reports completion on a Linear issue, closes the loop, and checks what should happen next at the project level. Use when the user wants to mark work done, close an issue, or replace the legacy `/linear:done` workflow.
capturing-linear-ideas
Captures a new idea into the Linear backlog as a type/idea issue without doing full triage. Use when the user wants quick idea capture, backlog intake, or a direct replacement for the legacy `/linear:idea` workflow.
debugging-test-failures
Systematically investigates failing tests, distinguishes between test bugs and implementation bugs, and drives a fix with verification. Use when the user wants to debug test failures or replace the legacy `/debug:test` workflow.
debugging-typescript-errors
Systematically investigates TypeScript compiler errors, traces the real type mismatch, and applies a minimal verified fix. Use when the user wants to debug type errors or replace the legacy `/debug:types` workflow.
Bio shown is the top-scored skill's repo description as a fallback — real GitHub bios land in a future update.