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

Dynamo Codebase Patterns

by DynamoDS in DynamoDS/Dynamo

Discovers and documents non-obvious structural and architectural patterns unique to this codebase.

Apache-2.0Auto-check passed

Install Dynamo Codebase Patterns

skills CLI
$ npx skills add DynamoDS/Dynamo --skill dynamo-codebase-patterns -a claude-code

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

GitHub CLI
$ gh skill install DynamoDS/Dynamo dynamo-codebase-patterns --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/DynamoDS/Dynamo.git skills-src && mkdir -p .claude/skills && cp -r skills-src/.claude/skills/dynamo-codebase-patterns .claude/skills/dynamo-codebase-patterns && 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
dynamo-codebase-patterns
GitHub stars
2k
Token cost
~1.5k tokens
SKILL.md length
698 words
Files
15
Skills in repo
13
Repo updated
First seen
Licence
Apache-2.0

At a glance

Discovers and documents non-obvious structural and architectural patterns unique to this codebase.

  • Works in 4 steps: Not in the docs: Is this derivable from… → Dynamo-specific types: Does this pattern… → Would a developer get this wrong?: Would… → …
  • SKILL.md covers Pattern Store, The Pattern Filter, Scan Mode and Review Mode, plus 2 more sections
  • Instructions only: no scripts, shell commands, URLs or credentials in SKILL.md

What it does

Dynamo Codebase Patterns is an agent skill from DynamoDS/Dynamo. Discovers and documents non-obvious structural and architectural patterns unique to this codebase. Reviews incoming changes for consistency with established patterns. Not style, conventions, features, or UX — only patterns that a developer from outside this repo would get wrong.

Its SKILL.md is about 1.5k tokens, which your agent loads only when the skill is triggered. The skill folder holds 15 other files (for example `patterns/README.md`, `patterns/dp-001-register-all-ports.md` and `patterns/dp-002-raises-modification-events.md`).

The repository describes itself as: Open Source Graphical Programming for Computational Design and Automation. The licence is Apache-2.0.

Example prompts

  • “Use the dynamo-codebase-patterns skill to discover and documents non-obvious structural and architectural patterns unique to this codebase”
  • “/dynamo-codebase-patterns”

Workflow steps

4 steps, taken from the first numbered list in SKILL.md.

  1. Not in the docs: Is this derivable from standard .NET/C# documentation alone? If yes — skip it.
  2. Dynamo-specific types: Does this pattern reference types, abstractions, or constraints that only exist in this codebase (NodeModel…
  3. Would a developer get this wrong?: Would a capable developer from outside this repo, reading only the type signatures and class names…
  4. Intentional design, not historical accident: Does this pattern appear consistently across multiple files? If two approaches to the same…

What it can do on your machine

Read from SKILL.md and the folder at commit 8cadc02. 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.

    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

Dynamo Codebase Patterns loads about 1.5k tokens when it runs. Until then it costs about 76 tokens; SKILL.md has 698 words of instructions outside code blocks.

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

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 DynamoDS/Dynamo at commit 8cadc02, republished under its Apache-2.0 licence (© DynamoDS). 698 words, ~1,488 tokens.

Download SKILL.mdSave it as .claude/skills/dynamo-codebase-patterns/SKILL.md (or your agent's skills folder). This skill also uses 14 other files; get the full folder from GitHub.
name
dynamo-codebase-patterns
description
Discovers and documents non-obvious structural and architectural patterns unique to this codebase. Reviews incoming changes for consistency with established patterns. Not style, conventions, features, or UX — only patterns that a developer from outside this repo would get wrong.

Dynamo Codebase Patterns

You maintain a living catalog of non-obvious implementation patterns specific to this codebase. Your purpose is to capture patterns that a capable C# developer, unfamiliar with Dynamo, would get wrong on first attempt — and to enforce them in code review.

You are not a style enforcer. Naming, formatting, and standard .NET patterns belong to the Janitor. You own structural and architectural patterns that are only meaningful in the context of this codebase.

Pattern Store

Your pattern catalog lives in patterns/. Each pattern is a separate .md file. You read from this folder when reviewing changes. You write to it when you discover a new confirmed pattern.

The catalog should stay under 40 patterns. Before adding a new pattern, confirm no existing pattern already covers it. If the catalog is at 40, propose retiring a pattern before adding one.

The Pattern Filter

Before recording any pattern, apply this filter. A pattern must pass all four:

  1. Not in the docs: Is this derivable from standard .NET/C# documentation alone? If yes — skip it.
  2. Dynamo-specific types: Does this pattern reference types, abstractions, or constraints that only exist in this codebase (NodeModel, WorkspaceModel, IScheduler, IExtension, etc.)? If no — likely skip it.
  3. Would a developer get this wrong?: Would a capable developer from outside this repo, reading only the type signatures and class names, produce the wrong implementation on first attempt? If no — skip it.
  4. Intentional design, not historical accident: Does this pattern appear consistently across multiple files? If two approaches to the same problem coexist in one file, investigate before recording either — look for TODO comments, deprecated attributes (e.g. [ComVisible], [ClassInterface] in WebView2 code), or mismatched vintage. Coexistence is often legacy debt, not a pattern to follow.

Scan Mode

When asked to scan a subsystem:

  1. Focus on one directory at a time — not the whole repo
  2. Look for patterns repeated across multiple files with consistent structure
  3. Apply the three-question filter to each candidate
  4. Propose at most 3–5 candidates per scan session
  5. Write each candidate as a candidate status pattern file in patterns/
  6. A candidate becomes confirmed only after it has been validated against 3 or more real file examples

Priority subsystems to scan first:

  • src/DynamoCore/Nodes — NodeModel subclassing, port registration
  • src/DynamoCore/Core — scheduler, execution model
  • src/Engine — geometry/computation boundary
  • src/Libraries — built-in node patterns
  • src/DynamoCoreWpf and view extension folders — view extension registration
  • src/DynamoCoreWpf/Utilities/WebView2Utilities.cs and src/LibraryViewExtensionWebView2 — Dynamo has its own DynamoWebView2 subclass of Microsoft's WebView2; all WebView2 usage must go through it. Key patterns: Initialize() instead of EnsureCoreWebView2Async, ConfigureSettings() after init, disposal ordering, and ExecuteScriptFunctionAsync for C#→JS calls
Show full SKILL.md (267 more words)Show less

Review Mode

When reviewing a PR or change:

  1. Identify which subsystem(s) the changed files belong to
  2. Load only patterns from patterns/ whose domain matches — do not load all patterns for every review
  3. For each confirmed pattern that applies, check whether the change follows it
  4. Flag deviations with: the pattern name, why it applies, and a concrete corrected example
  5. Do not flag candidate patterns as violations — they are not yet confirmed
  6. If a change appears to intentionally introduce a new pattern, ask rather than flag

Learning Triggers

Add a pattern candidate when:

  • You flag a structural correction in a PR review — create a candidate pattern file immediately on first sighting, even if you have only seen it once
  • You flag something in review and the author explains it is intentional — that explanation likely describes a pattern
  • A PR touches 5+ files with the same structural edit

When you flag a correction that already has a candidate file, increment its sightings count and add the PR to seen_in. At 3 sightings, promote the status to confirmed.

Flag an existing pattern for review when:

  • Its canonical_file has been significantly modified or deleted
  • You cannot find 3 files in the current codebase that still implement it

Retire a pattern when:

  • Fewer than 2 files still implement it
  • A migration has replaced all instances with a new form — create the new pattern, retire the old one

Pattern File Format

Each file in patterns/ follows this structure:

---
id: "dp-NNN"
name: ""
status: "candidate"    # candidate | confirmed | legacy | retired
domain: ""             # e.g. DynamoCore/Nodes, Engine, ViewExtensions
canonical_file: ""     # path to the best real example in the repo
added: "YYYY-MM-DD"
last_verified: "YYYY-MM-DD"
sightings: 1           # increment each time this is flagged in a PR; promote to confirmed at 3
seen_in: []            # PR numbers or scan sessions where this was observed
---

## Intent
One sentence: what this pattern ensures.

## Why non-obvious
Why a capable developer unfamiliar with this repo would get this wrong without being told.

## Correct form
[code example from the repo]

## Anti-pattern
[what a developer would naturally write instead, and why it breaks]

## When it applies
Conditions under which this pattern must be followed.

## Related patterns
- dp-NNN

The why non-obvious field is required — it is the justification for why this pattern belongs in the catalog at all.

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

Files

SKILL.md and 14 other files in .claude/skills/dynamo-codebase-patterns of DynamoDS/Dynamo.

  • SKILL.md
  • patterns/README.md
  • patterns/dp-001-register-all-ports.md
  • patterns/dp-002-raises-modification-events.md
  • patterns/dp-003-dynamowebview2-init-sequence.md
  • patterns/dp-006-asynctask-two-phase-init.md
  • patterns/dp-007-task-completion-scheduler-thread.md
  • patterns/dp-008-viewextension-lifecycle.md
  • patterns/dp-009-workspace-type-guard.md
  • patterns/dp-010-keepreference-ffi.md
  • patterns/dp-011-arbitrary-dimension-array.md
  • patterns/dp-012-dispose-derived-geometry.md
  • patterns/dp-013-isvisibleindynamolibrary.md
  • patterns/dp-014-asynctask-canmergewith.md
  • patterns/dp-015-property-change-manager.md

Open the folder on GitHubat commit 8cadc02

Compare with similar skills

Dynamo Codebase Patterns 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.

Dynamo Codebase Patterns compared with similar skills
SkillStarsUsed inTokensAuto-checkLicenceRepo updated
Dynamo Codebase Patterns this skillDynamoDS/Dynamo2k—~1.5kAutomated safety check: PassApache-2.0
Architecture Patternswshobson/agents40k—~2kAutomated safety check: PassMIT
Android Clean Architectureaffaan-m/ECC274k4 repos~2.2kAutomated safety check: PassMIT
Google Cloud Solution Architecturegoogle/skills21k—~3.5kAutomated safety check: PassApache-2.0
Architecture Patternsdavila7/claude-code-templates32k4 repos~483Automated safety check: PassMIT
Architecture Docs Writerprisma/orm48k—~1.6kAutomated safety check: PassApache-2.0

Similar skills

  • Architecture Patterns

    wshobson/agents

    Implement proven backend architecture patterns including Clean Architecture, Hexagonal Architecture, and Domain-Driven Design.

    40k GitHub stars~2k tokensUpdated 2 days ago
    DevelopmentAuto-check passed

  • Android Clean Architecture

    affaan-m/ECC

    Applies Clean Architecture to Android and Kotlin Multiplatform projects: module layout, dependency rules, UseCases, Repositories and data layer patterns.

    274k GitHub starsUsed in 4 repos~2.2k tokens
    DevelopmentAuto-check passed

  • Google Cloud Solution Architecture

    google/skills

    Official

    Interactively discovers requirements and designs holistic, multi-product system architectures, solution blueprints, and deployment recommendations for complex workloads on Google Cloud.

    21k GitHub stars~3.5k tokensUpdated today
    DevelopmentAuto-check passed

  • Architecture Patterns

    davila7/claude-code-templates

    Master proven backend architecture patterns including Clean Architecture, Hexagonal Architecture, and Domain-Driven Design to build maintainable, testable, and scalable systems.

    32k GitHub starsUsed in 4 repos~483 tokens
    DevelopmentAuto-check passed

  • Architecture Docs Writer

    prisma/orm

    Official

    Guides writing and rewriting architecture subsystem docs, ADRs and reference pages so they make sense to a developer with no prior project context.

    48k GitHub stars~1.6k tokensUpdated yesterday
    DevelopmentAuto-check passed

  • Architecture Decision Records

    affaan-m/ECC

    Capture architectural decisions as numbered ADR markdown files in docs/adr/ with context, alternatives considered, consequences, and an index README.

    274k GitHub starsUsed in 4 repos~1.8k tokens
    DevelopmentAuto-check passed

More from DynamoDS/Dynamo

All 13 skills in this repo

  • Dynamo Jira Ticket

    DynamoDS/Dynamo

    Create structured Jira tickets for Dynamo from bug reports, failing tests, or feature requests.

    2k GitHub stars~1.1k tokensUpdated today
    Auto-check passed

  • Dynamo Dotnet Expert

    DynamoDS/Dynamo

    Write and review C/.NET code in Dynamo following Dynamo coding standards, modern C patterns, and repo conventions.

    2k GitHub stars~909 tokensUpdated today
    Auto-check passed

  • Dynamo Onboarding

    DynamoDS/Dynamo

    Navigate the Dynamo codebase and produce architecture briefings.

    2k GitHub stars~1.9k tokensUpdated today
    Auto-check passed

  • Dynamo PR Description

    DynamoDS/Dynamo

    Generate PR descriptions for Dynamo that align with the team template section names and order.

    2k GitHub stars~880 tokensUpdated today
    Auto-check passed

  • Dynamo Skill Writer

    DynamoDS/Dynamo

    Author and maintain Dynamo agent skills. An agent skill from DynamoDS/Dynamo.

    2k GitHub stars~2.2k tokensUpdated today
    Auto-check passed

  • Dynamo Unit Testing

    DynamoDS/Dynamo

    Write comprehensive NUnit tests for the Dynamo codebase following Dynamo testing patterns, conventions, and architectural constraints.

    2k GitHub stars~622 tokensUpdated today
    Auto-check passed

Questions about Dynamo Codebase Patterns

What does Dynamo Codebase Patterns do?

Discovers and documents non-obvious structural and architectural patterns unique to this codebase. Dynamo Codebase Patterns is an agent skill from DynamoDS/Dynamo. Discovers and documents non-obvious structural and architectural patterns unique to this codebase.

How do I install Dynamo Codebase Patterns in Claude Code?

Run `npx skills add DynamoDS/Dynamo --skill dynamo-codebase-patterns -a claude-code`. Or copy the skill folder (.claude/skills/dynamo-codebase-patterns in DynamoDS/Dynamo) into .claude/skills/dynamo-codebase-patterns in your project. Claude Code loads it when a task matches its description.

How do I install Dynamo Codebase Patterns in Codex?

Run `npx skills add DynamoDS/Dynamo --skill dynamo-codebase-patterns -a codex`. Or copy the skill folder (.claude/skills/dynamo-codebase-patterns in DynamoDS/Dynamo) into .agents/skills/dynamo-codebase-patterns in your project. Codex loads it when a task matches its description.

Can I use Dynamo Codebase Patterns 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 DynamoDS/Dynamo --skill dynamo-codebase-patterns -a cursor` (or -a gemini-cli, github-copilot or opencode for the others). To copy it by hand, put the folder in .cursor/skills/dynamo-codebase-patterns, .gemini/skills/dynamo-codebase-patterns, .github/skills/dynamo-codebase-patterns and .opencode/skills/dynamo-codebase-patterns in your project.

What does Dynamo Codebase Patterns need to run?

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

Does Dynamo Codebase Patterns 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 Dynamo Codebase Patterns 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 Dynamo Codebase Patterns use?

Dynamo Codebase Patterns is published under the Apache-2.0 licence (the repository's licence). It allows redistribution, so the full SKILL.md is shown on this page.

How many tokens does Dynamo Codebase Patterns use?

About 1.5k tokens (SKILL.md is roughly 6k 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 Dynamo Codebase Patterns?

Skills that share tags, products or a category with Dynamo Codebase Patterns: Architecture Patterns (wshobson/agents, 40k stars), Android Clean Architecture (affaan-m/ECC, 274k stars), Google Cloud Solution Architecture (google/skills, 21k stars) and Architecture Patterns (davila7/claude-code-templates, 32k stars). The comparison table on this page puts their stars, adoption, token cost, safety result and licence side by side.

Who maintains Dynamo Codebase Patterns?

DynamoDS (a GitHub organization) maintains it in DynamoDS/Dynamo, which has 2,033 GitHub stars. The repository holds 13 skills in this directory. The repository was last updated on October 7, 2026.

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