feralbureau
UserAn AI dev agent built local-first. It gives your models direct access to your codebase, file system, and developer tools, turning them from chat assistants into active developers that actually get things done. Works with various providers, just like Claude Code, but private and fully under your control.
Categories
Indexed Skills (28)
ask_clarifying_question
Use this skill when a user's request is ambiguous enough that proceeding without clarification risks wasted effort — when a key assumption could significantly change the direction of the work. Triggers on: requests that are underspecified, vague, or where two very different interpretations are equally plausible. Also use when you've started down a path and hit a decision point where you need the user's preference to continue. Do NOT use this skill to ask obvious questions, delay answering, or ask for information you can reasonably infer.
code_review_self
Use this skill before finalizing and presenting any non-trivial code output — to review your own work for correctness, completeness, and quality. Triggers on: finishing a code implementation, "review what you just wrote", "check your work", "look it over before sending", or automatically when you've just written more than ~50 lines of new code or made changes across multiple files. This skill helps catch bugs, missing error handling, and style inconsistencies before the user sees the output.
debug_logic_bug
Use this skill when the user's code runs without crashing but produces wrong results, unexpected behavior, incorrect output, or fails a test for non-obvious reasons. Triggers on: "it works but gives the wrong result", "this test is failing and I don't know why", "the output is wrong", "it's not doing what I expect", "something weird is happening", "this should work but it doesn't". Logic bugs don't throw exceptions — they silently produce incorrect behavior, making them harder to find than runtime errors.
debug_runtime_error
Use this skill when the user shares a runtime error, exception, crash, stack trace, panic, or error log and wants to understand or fix it. Triggers on: pasted stack traces, "I'm getting an error", "it crashes with", "exception thrown", "panic:", "RuntimeError", "NullPointerException", "AttributeError", "TypeError", "segfault", "500 error", "unhandled exception". Use this skill immediately when you see a stack trace in the user's message — don't just read the last line, analyze the full trace.
design_api_contracts
Use this skill when designing or reviewing HTTP REST APIs, GraphQL schemas, RPC interfaces, or any API contract between services or between frontend and backend. Triggers on: "design an API for X", "what endpoints do I need?", "review this API design", "how should I structure this REST API?", "what's the right shape for this response?", "versioning strategy", "error response format", "API contract design", "OpenAPI spec". Also use proactively when implementing a backend feature that needs an API surface.
design_data_model
Use this skill when designing domain models, entities, value objects, aggregates, or the conceptual structure of the business domain — separate from database schema or ORM concerns. Triggers on: "how should I model this domain?", "what entities do I need?", "design the domain model for X", "should this be an entity or value object?", "what are the aggregates?", "how should these concepts relate?", "DDD domain modeling", "model this business concept in code". Also use when translating requirements into objects and relationships before writing any code.
design_database_schema
Use this skill when designing or modeling a new database schema — deciding how to represent domain concepts as tables, choosing relationships, normalization, or key strategy. Triggers on: "design a schema for", "how should I model X in the database?", "what tables do I need?", "how to represent this relationship?", "design the data model", "should I use a foreign key or embed?", "normalize this schema", "how do I model many-to-many?", "propose a migration for". Do NOT use for reviewing or assessing an existing schema — those tasks go through invoke_agent.
design_system_architecture
Use this skill when the user is making high-level system design decisions — how to structure a new system, how to decompose a monolith, how to connect services, where to put business logic, what technology stack to choose, or how different components should communicate. Triggers on: "how should I architect this?", "design a system for X", "should I use microservices or a monolith?", "how should I structure this backend?", "what's the right architecture for Y?", "design the system layout", "what components do I need?". Also use for architecture reviews.
design_ui_ux
Use this skill when the user is designing, evaluating, or improving a user interface — including component layouts, user flows, information architecture, interaction design, or accessibility. Triggers on: "how should I design this UI?", "what's the best layout for X?", "review this interface", "design a form for", "improve the UX of", "what should this screen look like?", "is this flow intuitive?", "accessibility review", "design the user journey for". Also use proactively when asked to build a UI component and the design hasn't been specified — propose the design before implementing.
django_clean_arch
Use this skill when working on a Django project that follows Clean Architecture, DDD (Domain-Driven Design), or a use-case-based structure — as opposed to standard Django MTV patterns. Triggers on: any Django code involving use cases, interactors, repositories, domain models (separate from Django ORM models), application services, or when the user mentions they use Clean Architecture with Django. Also use when the user asks how to structure Django code for testability, or how to avoid business logic in views or models.
explain_codebase
Use this skill when the user wants a tour, overview, or explanation of a codebase, project structure, or specific module — to understand how it's organized and how the pieces fit together. Triggers on: "explain how this project is structured", "walk me through the codebase", "how does this code work together?", "what does each folder do?", "I'm new to this project, where do I start?", "explain the architecture", "how does X connect to Y?". Also use when a new contributor needs onboarding into the code.
explain_concept
Use this skill when the user wants to understand a concept, technology, pattern, or principle — not to produce code right now, but to genuinely understand something. Triggers on: "explain X to me", "how does X work?", "what is X?", "I don't understand Y", "can you walk me through Z?", "what's the difference between A and B?", "why do people use X?", "when should I use X vs Y?". This skill shifts the focus from code output to clear, accurate, educational explanation tailored to the user's level.
find_root_cause
Use this skill when the user is dealing with a bug or problem and the immediate error/symptom is clear but the underlying reason is not. Triggers on: "why is this happening?", "what's actually causing this?", "this is a symptom of something deeper", "I keep having this bug", "this keeps happening", "I fixed it but it came back". This skill helps distinguish the true root cause from proximate causes and surface-level symptoms — so that the fix actually works long-term, not just temporarily.
gather_context
Use this skill before working on any task that touches existing code — to pull the relevant code chunks, project rules, and known facts before writing or reasoning. Triggers on: any implementation or debugging task where you haven't yet read the relevant files, "make a change to", "fix", "add to", "update", or any task where missing context could lead you to contradict existing patterns. Do NOT use for pure explanation questions or tasks where you already have the full relevant code in context.
git_operation
Use this skill for Git operations — committing, branching, merging, rebasing, resolving conflicts, undoing changes, writing commit messages, or understanding git history. Triggers on: "how do I commit", "write a commit message", "I have a merge conflict", "how to undo this", "rebase onto main", "cherry-pick", "git blame", "squash my commits", "how do I revert", "push to branch", "git stash". Also use when the user needs to understand what git commands to run for a specific workflow.
handle_build_failure
Use this skill when the user pastes a build error, compiler error, CI failure, linker error, type error, or any error that prevents the code from compiling or building. Triggers on: build output with errors, "it won't compile", "CI is failing", "the build is broken", "type error", "cargo build failed", "tsc error", "mypy failed", "missing dependency", "linker error", "ImportError at build time". This is distinct from runtime errors (code compiles but crashes) — build failures prevent the code from running at all.
handle_test_failure
Use this skill when the user pastes failing test output and wants to understand why the test is failing or how to fix it. Triggers on: pasted pytest/Jest/cargo test output, "this test is failing", "test is red", "assertion error in test", "why is this test failing?", "the test suite broke". This is distinct from production bugs — the code may work fine in production, but the test is asserting something that's wrong or the test itself is broken.
modify_existing_code
Use this skill when the user asks you to change, fix, update, extend, or edit existing code in a file that already exists. Triggers on: "add a field to", "change the behavior of", "update this function", "extend this class", "I want X to also do Y", "modify", "edit", "patch". Use this skill to perform surgical, minimal edits that respect the existing code's style, conventions, and invariants — rather than rewriting more than necessary. Critical for avoiding regressions.
planning_complex_change
Use this skill when the user needs to plan a large, multi-step code change before starting to implement it — such as adding a new feature that spans multiple files, a significant refactor, introducing a new architectural pattern, or any change that could go wrong without a clear plan. Triggers on: "how should I approach this?", "plan this out for me", "I want to add X but it touches many files", "what's the best way to implement Y?", "help me think through this", "design a solution for". Use this skill before writing code, not after.
react_component
Use this skill when building, editing, or reviewing React components, hooks, context providers, or frontend state management. Triggers on: "create a React component", "write a hook for", "add a context", "build a UI for", "frontend component", "TSX", ".tsx file", React state management, "useEffect", "useState", custom hooks, component composition. Also use when the user asks how to structure React code for maintainability, performance, or testability.
refactor_to_pattern
Use this skill when the user wants to restructure existing code to follow a specific architectural or design pattern — such as Repository, Use Case / Interactor, Service Layer, Factory, Strategy, Observer, CQRS, DDD aggregates, or Clean Architecture. Triggers on: "apply the repository pattern", "refactor to use cases", "extract this into a service", "separate concerns", "make this follow DDD", "restructure this to be cleaner", "I want to apply X pattern". Also use when the user says something is "too tangled" or "hard to test" and needs a structural solution.
seaorm_query
Use this skill when writing database queries, migrations, or model definitions using SeaORM (Rust async ORM). Triggers on: "SeaORM", "sea_orm", "sea-orm", "EntityTrait", "ActiveModel", "QueryFilter", "RelationTrait", Rust database queries, "sea-orm-migration", "DatabaseConnection". Also use when the user asks how to do a JOIN, a conditional query, an upsert, pagination, or transaction in SeaORM.
tauri_ipc
Use this skill when working on Tauri applications that involve communication between the Rust backend and the JavaScript/TypeScript frontend — including defining commands, invoking them from the frontend, handling events, passing complex types across the IPC boundary, or managing errors across the boundary. Triggers on: "tauri command", "invoke()", "#[tauri::command]", "Tauri IPC", "call Rust from JS", "emit event from Rust", "listen to event in frontend", "tauri::AppHandle", "tauri plugin". Also use when the user asks how to pass data between Rust and TypeScript in Tauri.
trace_data_flow
Use this skill when the user needs to understand how data moves through a system — where a value comes from, how it gets transformed, where it ends up, or why it's wrong at a specific point. Triggers on: "where does this value come from?", "how does data get from X to Y?", "trace this request", "follow this through the code", "what transforms this?", "how does this end up in the database?", "I want to understand the flow". Also use when debugging a bug that requires understanding data provenance.
write_migration
Use this skill whenever the user needs to write a database schema migration — adding/removing columns, creating/dropping tables, adding indexes, changing constraints, renaming, or backfilling data. Triggers on: "add a column to", "create a migration for", "I need to change the schema", "add an index", "rename this table", "backfill data", "alter the DB". Also use when the user adds a new model field and needs a migration to match. Works across Alembic (Python/SQLAlchemy), Django migrations, SeaORM migrations (Rust), and raw SQL.
write_new_module
Use this skill when the user asks you to create a new file, module, class, service, handler, repository, or any other new code artifact from scratch. Triggers on phrases like "create a new", "add a module for", "write a service that", "I need a file that", "scaffold a", "implement a new". Use it even when the user just describes a capability they want and expects you to figure out the right file structure. This skill ensures new code follows proper structure, naming, and architectural conventions rather than just dumping code into a file.
write_tests
Use this skill when the user wants to write tests — unit tests, integration tests, end-to-end tests, or property-based tests. Triggers on: "write tests for", "add test coverage", "test this function", "I need a test that", "how do I test this", "add a unit test", "write an integration test". Also use proactively when the user just wrote new code and hasn't mentioned tests — suggest and write tests for the most important behaviors. Works with pytest, unittest, Jest, Vitest, Rust's built-in test framework, and others.
fix_msbuild_rsp_error
Use this skill when `dotnet build` fails with `MSB1001: Unknown switch` and the output contains "Switches appended by response files: Switch: -". This is a stray MSBuild response file outside the repo injecting a bare `-` into the build command. Triggers on: MSB1001, "Unknown switch", "Switches appended by response files", "Switch: -" in dotnet build output.
Bio shown is the top-scored skill's repo description as a fallback — real GitHub bios land in a future update.