New: 97,000+ skills indexed from GitHub repos with 100+ stars · every skill safety-checkedBrowse top skillsTop skills
Esc to closeBrowse all skills
Submit a skillBrowse skills
Submit a skillBrowse skills

Agent skill

Dev Rules

by rust-dd in rust-dd/tako

General coding-style rules to apply to every project. An agent skill from rust-dd/tako.

MITAuto-check passedBackend & APIs

Install Dev Rules

skills CLI
$ npx skills add rust-dd/tako --skill dev-rules -a claude-code

Project install by default; add -g for ~/.claude/skills/.

GitHub CLI
$ gh skill install rust-dd/tako dev-rules --agent claude-code

Project scope by default; add --scope user for a personal install. Needs GitHub CLI 2.90.0 or later (public preview).

Manual copy
$ git clone --depth 1 https://github.com/rust-dd/tako.git skills-src && mkdir -p .claude/skills && cp -r skills-src/.claude/skills/dev-rules .claude/skills/dev-rules && rm -rf skills-src

Use ~/.claude/skills/ instead of .claude/skills for a personal install. The folder must contain SKILL.md.

Claude Code skills documentation · loads skills from .claude/skills/

Facts

Skill name
dev-rules
GitHub stars
162
Token cost
~810 tokens
SKILL.md length
349 words
Files
1
Skills in repo
2
Repo updated
First seen
Licence
MIT

At a glance

General coding-style rules to apply to every project. An agent skill from rust-dd/tako.

  • Editing source code
  • SKILL.md covers Comments, Source-file structure and When in doubt
  • Instructions only: no scripts, shell commands, URLs or credentials in SKILL.md
  • Doc comments — especially when adding new files

What it does

Dev Rules is an agent skill from rust-dd/tako. General coding-style rules to apply to every project. Use when writing or editing source code, comments, or doc comments — especially when adding new files or refactoring.

Its SKILL.md is about 810 tokens, which your agent loads only when the skill is triggered. It is a single SKILL.md file with no bundled scripts.

It sits in Backend & APIs, covering Technical documentation, Plain language and style rules and Realtime and WebSockets. It works with gRPC, OpenAPI, GraphQL and Rust. The repository describes itself as: Multi-transport Rust web framework: HTTP/1.1, HTTP/2, HTTP/3, WebSocket, SSE, gRPC, TCP/UDP and Unix sockets behind one router, on Tokio or Compio. The licence is MIT.

When your agent uses it

  • Editing source code
  • Doc comments — especially when adding new files

Example prompts

  • “/dev-rules”

What it can do on your machine

Read from SKILL.md and the folder at commit 7fa9c80. It shows what the files ask for, not the result of running them.

  • Tool permissions

    Pre-approves nothing: there is no allowed-tools line, so your agent's usual permission prompts apply.

    From allowed-tools in the SKILL.md frontmatter.

  • Runs code

    No scripts in the folder and no shell commands in SKILL.md (its code samples are rust).

    From the folder's file list and the shell code blocks in SKILL.md.

  • Network

    No URLs in SKILL.md.

    From URLs in SKILL.md, links to its own repository left out.

  • Credentials

    Names no API keys, tokens, secrets or passwords.

    From names ending in _API_KEY, _TOKEN, _SECRET, _KEY or _PASSWORD in SKILL.md.

Context cost

Dev Rules loads about 810 tokens when it runs. Until then it costs about 45 tokens; SKILL.md has 349 words of instructions outside code blocks.

Always · name and description, kept in context so the agent knows when to use it
~45
When it runs · the whole SKILL.md, loaded when a task matches
~810

Estimates: characters ÷ 4, the usual rule of thumb; real counts depend on the model's tokenizer. Scripts and assets cost tokens only if the agent reads them.

Safety

Auto-check passed

The automated check found no risky patterns in SKILL.md.

Automated static check — not a guarantee. Review scripts before installing. It scans the text of SKILL.md for risky patterns (piping downloads into a shell, reading credential files, hidden Unicode, destructive commands); files beside SKILL.md are not scanned.

SKILL.md

The full file from rust-dd/tako at commit 7fa9c80, republished under its MIT licence (© rust-dd). 349 words, ~810 tokens.

Download SKILL.mdSave it as .claude/skills/dev-rules/SKILL.md (or your agent's skills folder).
name
dev-rules
description
General coding-style rules to apply to every project. Use when writing or editing source code, comments, or doc comments — especially when adding new files or refactoring.

General Dev Rules

These are user-wide style rules. Apply them everywhere unless a project's own CLAUDE.md explicitly overrides one of them.

Comments

Banner / divider comments are forbidden

Do not write decorative section banners. Examples of what NOT to do:

rust
// ----- top-level convenience re-exports -----------------------------------------
// =============== HELPERS ===============
// /////////////// Server entry points ///////////////
// --- Database setup ---
// ===== INTERNAL HELPERS =====

These add visual noise, make diffs ugly, and rot when code moves. If a section is large enough that a header feels useful, that is a signal to split the file or move items into a submodule instead of papering over it with a banner.

If a logical grouping inside one file truly helps the reader, use a single-line plain comment with a short noun phrase (no dashes, equals signs, slashes, or trailing fillers):

rust
// re-exports from tako-core
pub use tako_core::body;
pub use tako_core::types;
Don't restate what code already says

Skip comments that just paraphrase the next line. Code with good names doesn't need narration.

rust
// BAD — restates the code
// Increment counter
counter += 1;

// BAD — narrates structure that's obvious from the AST
// Loop through users
for user in users { ... }

A comment earns its place only when it explains the why that isn't visible: a hidden constraint, a workaround, an invariant, a surprising performance choice.

No "added for X / used by Y / changed in PR Z" notes

Don't reference tasks, PRs, callers, or migration history in comments. That belongs in commit messages and PR descriptions, where it stays attached to the diff and doesn't rot.

rust
// BAD
// added for the new auth flow (PR #482)
// used by the worker pool refactor
// removed once compio 0.18 ships

// OK if the rationale itself is durable
// SO_REUSEPORT distributes accepts at the kernel level — required for
// thread-per-core to avoid contending on a single accept queue.
No multi-paragraph docstrings unless the API is genuinely subtle

A one-line summary plus an example is enough for 95% of public items. Walls of doc text get skimmed and outdated. If something needs paragraphs of warnings, the API design is probably wrong.

Stale // TODO / // FIXME markers

Only leave a TODO if there is a concrete next action. Vague TODOs ("// TODO: improve this") get ignored forever. If there is no clear next step, delete the comment and just write the code.

Source-file structure

  • Don't separate file regions with banner comments — let module boundaries, blank lines, and good ordering do the work.
  • Keep imports in groups (std / external / local) without decorating the groups.
  • Don't add a trailing comment to mark "end of impl block" or similar — the closing brace is sufficient.

When in doubt

Prefer no comment over a marginal one. Reviewers can ask if something is unclear; deleting noise improves signal.

© rust-dd, MIT. Rendered from Markdown: HTML in the file is shown as text, images as links, and headings moved down two levels. Raw file

Files

Just SKILL.md in .claude/skills/dev-rules of rust-dd/tako.

Open the folder on GitHubat commit 7fa9c80

Compare with similar skills

Dev Rules next to the 5 skills that share the most tags, products or categories with it. Stars are the repository's; “used in” counts other GitHub owners with a copy.

Dev Rules compared with similar skills
SkillStarsUsed inTokensAuto-checkLicenceRepo updated
Dev Rules this skillrust-dd/tako162—~810Automated safety check: PassMIT
Release WorkflowGoldziher/spikard123—~909Automated safety check: PassMIT
Use Yaakmountain-loop/yaak19k—~1.9kAutomated safety check: PassMIT
SpikardGoldziher/spikard123—~799Automated safety check: PassMIT
API ForgeEliasOulkadi/shokunin114—~2.9kAutomated safety check: PassMIT
API Protocol Securityzhaji2333/CkSKILLS112—~520Automated safety check: PassMIT

Similar skills

  • Release Workflow

    Goldziher/spikard

    Release/publish the spikard Rust core crate and CLI end-to-end.

    123 GitHub stars~909 tokensUpdated 4 days ago
    Backend & APIsAuto-check passed

  • Use Yaak

    mountain-loop/yaak

    A skill your agent uses when the user mentions Yaak, a Yaak workspace, or the yaak command, or asks to call, hit, or smoke test HTTP/REST endpoints, save or organize API requests for reuse or manual…

    19k GitHub stars~1.9k tokensUpdated today
    Backend & APIsAuto-check passed

  • Spikard

    Goldziher/spikard

    Scaffold Spikard projects and generate code from OpenAPI, AsyncAPI, OpenRPC, GraphQL, and Protobuf schemas using the Spikard CLI or its MCP server.

    123 GitHub stars~799 tokensUpdated 4 days ago
    Backend & APIsAuto-check passed

  • API Forge

    EliasOulkadi/shokunin

    Design REST/GraphQL APIs with OpenAPI 3.1, error handling, pagination, rate limiting, webhooks, and idempotency.

    114 GitHub stars~2.9k tokensUpdated 2 days ago
    Backend & APIsAuto-check passed

  • API Protocol Security

    zhaji2333/CkSKILLS

    当目标存在REST/GraphQL/gRPC/WebSocket接口、Swagger/OpenAPI文档、调试端点（actuator/console）、旧版本API、内部接口、微服务网关，或需要测试HTTP走私、DoS、速率限制时调用。负责API全方法测试、BOLA越权、GraphQL深度攻击、协议层漏洞挖掘。

    112 GitHub stars~520 tokensUpdated 22 days ago
    Backend & APIsAuto-check passed

  • System Design Communication

    HoangNguyen0403/agent-skills-standard

    Select how services talk: REST, gRPC, GraphQL, WebSocket, SSE, or webhook per hop, sync versus async per flow, service discovery mode, and DNS/edge routing.

    570 GitHub stars~894 tokensUpdated yesterday
    Backend & APIsAuto-check passed

More from rust-dd/tako

  • Docs Writing

    rust-dd/tako

    Conventions for writing and maintaining tako documentation pages under website/content/docs/.

    162 GitHub stars~2.8k tokensUpdated 6 days ago
    Auto-check passed

Works with

Categories

Questions about Dev Rules

What does Dev Rules do?

General coding-style rules to apply to every project. An agent skill from rust-dd/tako. Dev Rules is an agent skill from rust-dd/tako. General coding-style rules to apply to every project.

When should I use Dev Rules?

Dev Rules fits situations like: editing source code; doc comments — especially when adding new files.

How do I install Dev Rules in Claude Code?

Run `npx skills add rust-dd/tako --skill dev-rules -a claude-code`. Or copy the skill folder (.claude/skills/dev-rules in rust-dd/tako) into .claude/skills/dev-rules in your project. Claude Code loads it when a task matches its description.

How do I install Dev Rules in Codex?

Run `npx skills add rust-dd/tako --skill dev-rules -a codex`. Or copy the skill folder (.claude/skills/dev-rules in rust-dd/tako) into .agents/skills/dev-rules in your project. Codex loads it when a task matches its description.

Can I use Dev Rules in Cursor, Gemini CLI or GitHub Copilot?

Cursor, Gemini CLI, GitHub Copilot and OpenCode also load SKILL.md folders. With the skills CLI, run `npx skills add rust-dd/tako --skill dev-rules -a cursor` (or -a gemini-cli, github-copilot or opencode for the others). To copy it by hand, put the folder in .cursor/skills/dev-rules, .gemini/skills/dev-rules, .github/skills/dev-rules and .opencode/skills/dev-rules in your project.

What does Dev Rules need to run?

SKILL.md names no scripts, command-line tools or credentials: Dev Rules is instructions for the agent only.

Does Dev Rules access the network?

SKILL.md contains no URLs. Any network use would come from the scripts or tools the agent runs. This is read from the text; nothing was executed.

Is Dev Rules safe to install?

Our automated static check of SKILL.md found no risky patterns, such as piping downloads into a shell, reading credential files or hidden Unicode. It is not a guarantee. Review the folder before installing.

What licence does Dev Rules use?

Dev Rules is published under the MIT licence (the repository's licence). It allows redistribution, so the full SKILL.md is shown on this page.

How many tokens does Dev Rules use?

About 810 tokens (SKILL.md is roughly 3.2k characters). Agents keep only the skill's name and description in context until a task matches; then they load SKILL.md in full.

What are the alternatives to Dev Rules?

Skills that share tags, products or a category with Dev Rules: Release Workflow (Goldziher/spikard, 123 stars), Use Yaak (mountain-loop/yaak, 19k stars), Spikard (Goldziher/spikard, 123 stars) and API Forge (EliasOulkadi/shokunin, 114 stars). The comparison table on this page puts their stars, adoption, token cost, safety result and licence side by side.

Who maintains Dev Rules?

rust-dd (a GitHub organization) maintains it in rust-dd/tako, which has 162 GitHub stars. The repository holds 2 skills in this directory. The repository was last updated on October 1, 2026.

Source: rust-dd/tako on GitHub. Facts on this page come from the repository at the commit we read; the author's words are quoted as theirs.