Profile My skills Saved Collections Edit profile Submit a skill

← all publishers

quick-brown-foxxx

@quick-brown-foxxx source repo

66 published skills

  1. ▌
    Managing State · quick-brown-foxxx
    State management patterns: Zustand stores, React Context, URL state, form state. Use when creating stores, managing component state, or choosing state patterns. ALWAYS load this skill when writing any react code!
    0
    installs
  2. ▌
    Testing React TS · quick-brown-foxxx
    React/TypeScript testing with Vitest and Playwright: philosophy, component tests, integration tests, e2e tests, test infrastructure. Use when writing tests or setting up test infrastructure. ALWAYS load this for working with tests in react.
    0
    installs
  3. ▌
    Building API Clients · quick-brown-foxxx
    Type-safe API clients: HTTP client, Zod validation, Result pattern, Swagger codegen. Use when creating API integrations or working with backend services. ALWAYS load this skill when working with APIs in react clients
    0
    installs
  4. ▌
    Writing React TS Code · quick-brown-foxxx
    Core React/TypeScript standards: strict typing, Result-based error handling, component patterns, code style. Use when writing or editing any React/TypeScript code. ALWAYS load this skill before working with any react code.
    0
    installs
  5. ▌
    Building UI Components · quick-brown-foxxx
    UI component patterns: shadcn/ui, component organization, variant system. Use when building or modifying React UI components. ALWAYS load this skill when working with react code.
    0
    installs
  6. ▌
    Setting Up Nextjs Projects · quick-brown-foxxx
    Next.js project setup: directory structure, configuration, tooling, environment validation. Use when bootstrapping new projects or understanding project layout.
    0
    installs
  7. ▌
    Qt Devtools Setup · quick-brown-foxxx
    ALWAYS LOAD THIS SKILL WHEN SETTING UP QT-AI-DEV-TOOLS, INITIALIZING A WORKSPACE, OR BOOTING THE VM. Do not configure qt-ai-dev-tools environments directly — use this skill first. Installation, workspace init, VM boot, environment verification, and self-update for headless Qt UI testing.
    0
    installs
  8. ▌
    Qt Devtools Runtime Eval · quick-brown-foxxx
    ALWAYS LOAD THIS SKILL WHEN EXECUTING CODE INSIDE A RUNNING QT/PYSIDE APP VIA THE BRIDGE. Do not use bridge eval directly — use this skill first. Runtime Python execution inside Qt apps via Unix socket, Chrome DevTools evaluate_script equivalent for Qt.
    0
    installs
  9. ▌
    Qt Devtools Form And Input · quick-brown-foxxx
    ALWAYS LOAD THIS SKILL WHEN FILLING FORMS, HANDLING FILE DIALOGS, OR USING THE CLIPBOARD IN RUNNING QT/PYSIDE APPS. Do not automate multi-field input or file dialogs directly — use this skill first. Form filling recipes, QFileDialog automation, clipboard read/write. Clipboard and file dialog commands are alpha.
    0
    installs
  10. ▌
    Qt Devtools App Interaction · quick-brown-foxxx
    ALWAYS LOAD THIS SKILL WHEN TESTING QT/PYSIDE UI, CLICKING BUTTONS, INSPECTING WIDGETS, OR TAKING SCREENSHOTS. Do not interact with Qt widgets directly — use this skill first. AT-SPI accessibility-based inspect-interact-verify workflow, widget tree navigation, screenshot validation. Core commands are beta.
    0
    installs
  11. ▌
    Qt Devtools Desktop Integration · quick-brown-foxxx
    ALWAYS LOAD THIS SKILL WHEN INTERACTING WITH SYSTEM TRAY, DESKTOP NOTIFICATIONS, OR AUDIO IN RUNNING QT/PYSIDE APPS. Do not interact with OS-level desktop features directly — use this skill first. D-Bus system tray (SNI), notification monitoring, PipeWire audio virtual mic and recording. All commands are alpha.
    0
    installs
  12. ▌
    Testing Python · quick-brown-foxxx
    Python-specific extension to myai's `high-level-testing-strategy`, `test-driven-development`, and `manual-testing`. Load after those myai skills when writing Python tests, adding fixtures, or setting up pytest. Python testing with pytest: fixtures, CLI/e2e tests, mock servers, containerized testing, pytest-qt.
    0
    installs
  13. ▌
    Building Qt Apps · quick-brown-foxxx
    ALWAYS LOAD THIS SKILL WHEN WORKING WITH PYSIDE6, QT, OR DESKTOP GUI CODE. Do not write PySide6 or Qt code directly — use this skill first. PySide6 desktop apps: Manager→Service→Wrapper architecture, QML View+ViewModel (MVVM) integration, qasync integration, signals, system tray, testing.
    0
    installs
  14. ▌
    Setting Up Logging · quick-brown-foxxx
    ALWAYS LOAD THIS SKILL WHEN ADDING LOGGING, CONFIGURING LOG OUTPUT, OR SETTING UP COLORLOG IN PYTHON. Do not configure Python logging directly — use this skill first. Set up colored logging and stdout output for Python apps and CLI tools using colorlog.
    0
    installs
  15. ▌
    Writing Python Code · quick-brown-foxxx
    ALWAYS LOAD THIS SKILL WHEN WRITING OR EDITING PYTHON CODE. Do not write or modify Python files directly — use this skill first. Core Python standards: basedpyright strict typing, Result-based error handling, async patterns, security, code style.
    0
    installs
  16. ▌
    Setting Up Shortcuts · quick-brown-foxxx
    ALWAYS LOAD THIS SKILL WHEN ADDING KEYBOARD SHORTCUTS OR HOTKEYS TO A PYSIDE6/QT APP. Do not implement keyboard shortcuts directly — use this skill first. Set up customizable keyboard shortcuts for PySide6 apps with TOML config and platform-specific defaults.
    0
    installs
  17. ▌
    Building Multi UI Apps · quick-brown-foxxx
    Python-specific extension to myai's `architecting-changes`. Load after myai's `architecting-changes` when a Python app has multiple interfaces sharing logic, such as CLI, GUI, API, or automation entry points. Multi-interface Python apps: reusable core, thin adapters, composition root, and layered architecture for GUI + CLI + API sharing business logic.
    0
    installs
  18. ▌
    Setting Up Python Backends · quick-brown-foxxx
    Python-specific extension to myai's `setting-up-backends`. ALWAYS LOAD `setting-up-backends` FIRST, AND THAN THIS skill for Python backend tooling. Backend/API bootstrap for Python: FastAPI/Django choice, backend repo layout, app factory, SQLAlchemy+Alembic, pydantic at edge, migrations, and service-first conventions.
    0
    installs
  19. ▌
    Setting Up Python Projects · quick-brown-foxxx bundle
    Python-specific extension to myai's `setting-up-projects`. ALWAYS LOAD `setting-up-projects` FIRST, THAN THIS skill for Python tooling. Bootstrap general Python projects: uv, ruff, basedpyright, pytest, pre-commit, src layout, pyproject.toml, templates, bootstrap script, graceful shutdown code.
    0
    installs
  20. ▌
    Architecting Python Changes · quick-brown-foxxx
    Python-specific extension to myai's `architecting-changes`. Load after myai's `architecting-changes` when a Python feature, fix, refactor, or structure change requires architecture decisions about layers, wrappers, composition roots, framework choices, reusable cores, or where code should live. Python architecture guide + skill router for boundary placement, reusable core design, composition vs inheritance, framework vs custom choices, backend/service layering, and follow-up docs/skills.
    0
    installs
  21. ▌
    Repair Opencode Kilo Python Lsp Diagnostics · quick-brown-foxxx
    Use this skill if you see library resolution errors when doing Python file reads or writes via the edit tool. This may mean that your built-in LSP is misbehaving. Note: this is ONLY for Kilo/opencode. Repair the Kilo/opencode LSP (pyright) so Python third-party imports resolve correctly.
    0
    installs
  22. ▌
    API Design · quick-brown-foxxx
    Guides stable API and protocols/interfaces design. Use when designing APIs, module boundaries, or any public programmable interface. Use when creating REST or GraphQL endpoints, defining type contracts between modules, or establishing boundaries between frontend and backend.
    0
    installs
  23. ▌
    Doubt Early · quick-brown-foxxx
    Invoke fresh-context adversarial review before committing to non-trivial decisions. Use when about to implement under uncertainty, when requirements feel underspecified, when fixing something that "shouldn't exist", or when adding complexity to work around uncertainty. Catches both wrong solutions AND wrong problems (XY).
    0
    installs
  24. ▌
    Git Workflow · quick-brown-foxxx
    ALWAYS LOAD THIS BEFORE COMMITTING FOR THE FIRST TIME IN SESSION, OR WHEN CREATING GIT WORKTREES. Use for creating git branch, worktree isolation, atomic commits with messages, gitignore, git hooks, automated code quality checks, and multi-agent/worktree isolation.
    0
    installs
  25. ▌
    Brainstorming · quick-brown-foxxx
    Creates technical specs and designs for well-understood features. Use when requirements are clear but you need architecture, component design, data flow, or approach decisions before implementing. Not for vague ideas (use idea-sharpening first) or for trivially implementable changes.
    0
    installs
  26. ▌
    Manual Testing · quick-brown-foxxx
    Use when verifying real runtime behavior manually: browser UI, API, CLI, infrastructure, smoke tests, e2e flows, logs, database/admin side effects, or when automated tests are not trustworthy or not worth the cost. Realistic manual verification with environment preflight, isolation, evidence, and cleanup.
    0
    installs
  27. ▌
    Visual Mockups · quick-brown-foxxx bundle
    Browser-based interactive mockups, wireframes, and diagrams for UI exploration during brainstorming. Use when discussing layouts, visual design decisions, architecture diagrams, or any question where seeing options is better than describing them in text. Not for purely conceptual or text-based questions.
    0
    installs
  28. ▌
    Creating Slides · quick-brown-foxxx
    Use when the user asks to create slides, a presentation, a deck, or any slides-like deliverable. Sets up an open-slide workspace and hands the real slide work to open-slide's own auto-installed agent skills. Not for editing slide content directly — bootstrap the workspace first, then work together.
    0
    installs
  29. ▌
    Idea Sharpening · quick-brown-foxxx
    Refines vague ideas into sharp, validated concepts through structured divergent and convergent thinking. Use when a concept is still unclear, when the user asks to ideate or refine an idea, or when exploring options before converging on what to build. Not for clear implementation tasks or adversarial review of an existing plan.
    0
    installs
  30. ▌
    Prototype First · quick-brown-foxxx
    Helps fail fast on risky implementation steps by prototyping before committing to full code changes. Use during planning or implementation when a step is ambiguous, depends on multiple subsystems or flaky tools, may invalidate the current plan, or repeated fix attempts suggest a doom loop. Useful during both planning and implementation.
    0
    installs
  31. ▌
    Using My Skills · quick-brown-foxxx bundle
    Bootstrap skill that helps to understand other skills and available workflows. ALWAYS load this at the beginning of a new session before everything else. UNLESS it was already auto injected.
    0
    installs
  32. ▌
    Writing Scripts · quick-brown-foxxx
    ALWAYS LOAD THIS SKILL WHEN CREATING ANY STANDALONE SINGLE-FILE SCRIPT, AUTOMATION, OR TINY CLI TOOL FOR ANY LANGUAGE OR ECOSYSTEM. Do not create scripts directly — use this skill first. Single-file script patterns: when to use scripts vs projects, script layout, script body structure, CLI conventions, graceful shutdown, and ecosystem-specific examples for Python and TypeScript/Node.
    0
    installs
  33. ▌
    AI Edge Research · quick-brown-foxxx bundle
    Research current AI tools, frameworks, agents, models, and practices from practitioner signal rather than SEO or marketing. Use when the user asks what builders are actually adopting, what is trending in AI, or what is new in AI tooling and wants recency-aware, hype-resistant research.
    0
    installs
  34. ▌
    Building Backends · quick-brown-foxxx
    ALWAYS LOAD THIS SKILL WHEN DESIGNING OR CHANGING BACKEND, SERVICE, WORKER, OR API ARCHITECTURE: ROUTES, USE-CASE LAYERS, AUTH BOUNDARIES, PERSISTENCE, TRANSACTIONS, OR BACKGROUND JOBS. Do not shape backends directly — use this skill first. Backend architecture patterns: thin transport, reusable core, transaction ownership, auth/session boundaries, workers, idempotency, and infrastructure separation. Includes Python and TypeScript/Node ecosystem examples.
    0
    installs
  35. ▌
    Doing Code Review · quick-brown-foxxx
    Reviews code changes, PRs, diffs, branches, and agent-written code. Use when reviewing finished work, checking whether work is ready to merge, commit, or hand off, or requesting fresh-context or subagent review.
    0
    installs
  36. ▌
    Code Simplification · quick-brown-foxxx
    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.
    0
    installs
  37. ▌
    How To Write Skills · quick-brown-foxxx
    Helps create and refine portable, self-contained agent skills. ALWAYS USE when creating or editing a SKILL.md, reviewing skill frontmatter or instructions, or improving discoverability, triggering, portability, or skill structure.
    0
    installs
  38. ▌
    Setting Up Backends · quick-brown-foxxx
    ALWAYS LOAD THIS SKILL WHEN BOOTSTRAPPING A NEW BACKEND, API SERVICE, OR WORKER REPO FOR ANY LANGUAGE OR ECOSYSTEM. Do not scaffold backends directly — use this skill first. Backend/service directory layout, app factory pattern, wiring rules, defer-by-default infrastructure, and service-first project conventions.
    0
    installs
  39. ▌
    Setting Up Projects · quick-brown-foxxx
    ALWAYS LOAD THIS SKILL WHEN CREATING A NEW PROJECT, BOOTSTRAPPING A REPO, OR CHOOSING INITIAL PROJECT SHAPE FOR ANY LANGUAGE OR ECOSYSTEM. Do not scaffold projects directly — use this skill first. Project shape decisions, directory layout patterns, bootstrap checklist, graceful shutdown strategy, domain adaptation, and language-specific extension routing.
    0
    installs
  40. ▌
    Shipping And Launch · quick-brown-foxxx
    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.
    0
    installs
  41. ▌
    Architecting Changes · quick-brown-foxxx
    Use when a feature, refactor, bug fix, or project setup needs an architecture decision about boundaries, layers, wrappers, reusable cores, framework choices, composition roots, shared logic, or where code should live.
    0
    installs
  42. ▌
    CI CD And Automation · quick-brown-foxxx
    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.
    0
    installs
  43. ▌
    Systematic Debugging · quick-brown-foxxx
    Use when builds break, behavior does not match expectations, or you encounter a bug, test failure, CI failure, flaky behavior, or unexpected behavior. Systematic root-cause debugging with structured triage, error-specific patterns, and evidence-based investigation before proposing fixes.
    0
    installs
  44. ▌
    Openai AI Integration · quick-brown-foxxx
    Use when integrating an OpenAI-compatible LLM API into an app, CLI, tool, or service: choosing the SDK, shaping chat-completion requests, configuring base URL/model/reasoning-effort, structured output via response_format, resilient JSON parsing, and retry handling. Language-agnostic guidance with Python examples and TypeScript references.
    0
    installs
  45. ▌
    Receiving Code Review · quick-brown-foxxx
    Handles code review feedback with technical rigor. Use when receiving reviewer comments, PR feedback, agent review findings, requested changes, or suggestions that need verification before implementation.
    0
    installs
  46. ▌
    Teamlead Coordination · quick-brown-foxxx
    ALWAYS LOAD THIS SKILL WHEN ACTING AS A TEAMLEAD AGENT SESSION. Do not run a Teamlead-led multi-epic session directly — use this skill first. Backlog-driven multi-epic operating model, slice contract, teammate archetypes, verify-triage-fix chains, epic reject protocol, periodic analysis teammate, and the user-picks-teamlead boundary. Use when a user explicitly starts a Teamlead session, when coordinating teammates across multiple epics or features, when maintaining a project backlog across long autonomous work, when building a sequence of verify-fix teammate passes, or when running a comparison/merge flow for very big epics.
    0
    installs
  47. ▌
    Bug Root Cause Tracing · quick-brown-foxxx
    Use during debugging when the root cause is not obvious, the error appears deep in a call chain, or bad state must be traced back to the caller, test, or code path that introduced it. Backward tracing for invalid values, wrong files, unexpected side effects, and test pollution.
    0
    installs
  48. ▌
    Documentation And Adrs · quick-brown-foxxx
    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.
    0
    installs
  49. ▌
    Engineering Principles · quick-brown-foxxx
    ALWAYS LOAD THIS SKILL BEFORE ANY CODING-RELATED WORK: writing or editing code, fixing bugs, debugging, planning architecture, designing APIs, setting up projects, testing, reviewing code, refactoring, CI/CD, release automation, security, performance, or researching implementation behavior. It provides the local engineering philosophy: strict types, validation, explicit errors, trustworthy tests, clear architecture, one strict tool per job, frameworks over ad hoc patterns, and explicit-over-clever code.
    0
    installs
  50. ▌
    Security And Hardening · quick-brown-foxxx
    Hardens code against vulnerabilities with environment-aware guardrails. Use when handling user input, authentication, data storage, external integrations, sessions, third-party services, webhooks, file uploads, payment data, or PII.
    0
    installs
  51. ▌
    Architecting Test Infra · quick-brown-foxxx
    Use when setting up or redesigning test infrastructure, BDD frameworks, fixtures, state isolation, data builders, seed layers, local services, preflight checks, test environments, or flaky/complex test setup. Architecture step for scalable, realistic test suites before writing individual tests.
    0
    installs
  52. ▌
    Planning Implementation · quick-brown-foxxx
    Breaks validated specs into ordered, implementable tasks with explicit acceptance criteria and verification. Use when you have a spec or a task and need to decompose work into concrete steps with dependencies, file paths, and checkpoints. Not for simple single-file changes with obvious scope or specs with sufficient implementation detail built in.
    0
    installs
  53. ▌
    Test Driven Development · quick-brown-foxxx
    Use when implementing automated tests and code for new behavior, bug fixes, regressions, or behavior changes after test cases are known. BDD/test-first red-green-refactor, prove the test can fail, implement minimal code, keep scenario text near tests, and verify without orthodox ceremonies.
    0
    installs
  54. ▌
    Performance Optimization · quick-brown-foxxx
    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.
    0
    installs
  55. ▌
    Upstream Source Research · quick-brown-foxxx
    ALWAYS LOAD THIS SKILL WHEN RESEARCHING AN UPSTREAM PACKAGE OR HOSTED REPOSITORY SUCH AS GITHUB OR GITLAB FOR SOURCE CODE, ISSUES, REFS, RELEASES, OR COMMIT HISTORY. Do not assume web-only research is enough before reading this skill.
    0
    installs
  56. ▌
    Incremental Implementation · quick-brown-foxxx
    Use when starting to implement a feature, refactor, bug fix, or planned task that is too large to do safely in one edit. Guides thin slices, scope discipline, frequent lint/typecheck feedback, right-sized tests, blocker escalation, and handoff.
    0
    installs
  57. ▌
    High Level Testing Strategy · quick-brown-foxxx
    Use when deciding what behavior needs tests, designing test cases, choosing automated vs manual verification, reviewing test coverage quality, or planning tests before implementation. BDD-first test strategy, behavior scenarios, automation scope, mock boundaries, and routing to TDD, manual testing, or test-infra architecture.
    0
    installs
  58. ▌
    Bug Protection Multi Layered · quick-brown-foxxx
    Use after fixing recurring, high-risk, or boundary-crossing bugs to prevent the same class from recurring. Adds entry validation, business checks, environment guards, and forensic instrumentation. Skip trivial one-off fixes where layered defenses add more complexity than protection.
    0
    installs
  59. ▌
    Writing Upstream Bug Reports · quick-brown-foxxx
    Use when investigating a bug, regression, crash, Linux/system issue, package problem, or third-party library defect and you need a structured upstream bug report ready for maintainer issue trackers.
    0
    installs
  60. ▌
    Executing Plans With Subagents · quick-brown-foxxx
    Use when executing an implementation plan by delegating bounded tasks to fresh subagents. Applies to medium/big or multi-step plans where inline execution would overload context, where independent slices can be delegated, or where agent-written work needs explicit integration, review, and verification loops.
    0
    installs
  61. ▌
    Release Automation Small Repos · quick-brown-foxxx
    Helps bootstrap or reshape small repositories that build artifacts from source and publish to GitHub Releases, package registries, extension marketplaces, or packaging ecosystems. Use for release workflows, upstream sync automation, update PRs, version tags, generated artifacts, and end-to-end release verification.
    0
    installs
  62. ▌
    Verification Before Completion · quick-brown-foxxx
    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
    0
    installs
  63. ▌
    When And How To Run Parallel Agents · quick-brown-foxxx
    Use when deciding whether multiple agents can work in parallel on independent tasks, failures, research threads, verification checks, or implementation slices. Guides independence checks, how to properly dispatch parallel work, write focused prompts, integrate agents, and when not to parallelize.
    0
    installs
  64. ▌
    Manual Interacting With Codex Via CLI · quick-brown-foxxx
    ALWAYS LOAD THIS SKILL WHEN USER ASKS TO CHECK, VERIFY, SMOKE-TEST, REPRODUCE, OR RUN SOMETHING THROUGH `codex`, OR WHEN A PLAN CONTAINS A STEP TO VERIFY THROUGH `codex`. Use for scenario-appropriate `codex exec`, Codex CLI automation, sandbox/approval checks, config/profile isolation, skill/plugin/MCP smoke tests, CI bootstrap, and real non-interactive Codex CLI evidence.
    0
    installs
  65. ▌
    Manual Interacting With Opencode Via CLI · quick-brown-foxxx
    ALWAYS LOAD THIS SKILL WHEN USER ASKS TO CHECK, VERIFY, SMOKE-TEST, REPRODUCE, OR RUN SOMETHING THROUGH `opencode`, OR WHEN A PLAN CONTAINS A STEP TO VERIFY THROUGH `opencode`. Use for scenario-appropriate `opencode run`, `opencode models`, skill or plugin smoke tests, provider config checks, CI bootstrap, and tool-call verification through real OpenCode CLI execution.
    0
    installs
  66. ▌
    Manual Interacting With Claude Code Via CLI · quick-brown-foxxx
    ALWAYS LOAD THIS SKILL WHEN USER ASKS TO CHECK, VERIFY, SMOKE-TEST, REPRODUCE, OR RUN SOMETHING THROUGH `claude` OR Claude Code CLI, OR WHEN A PLAN CONTAINS A STEP TO VERIFY THROUGH Claude Code. Use for non-interactive `claude -p`, background agent checks, permission/config isolation, subagent, skill, MCP, plugin, worktree, and wrapper-sensitive Claude Code CLI verification.
    0
    installs