CtrlK
BlogDocsLog inGet started
Tessl Logo
SkillPublic

pythonic-code

Write, refactor, and review Python for clarity, explicit behavior, local reasoning, strong types, constructive domain modeling, and minimal abstraction. Use when creating or changing nontrivial Python, simplifying object-heavy, helper-heavy, or overly procedural code, evaluating whether code is Pythonic, or reviewing Python maintainability in Basic Memory repositories.

Quality

83%

Does it follow best practices?

Run evals on this skill

Adds up to 20 points to the overall score

View guide
SecuritybySnyk

Passed

No findings from the security scan

SKILL.md
Quality
Evals
Security

Quality

Content

75%Weight 40%Scale 1-5

Reviews the quality of instructions and guidance provided to agents. Good implementation is clear, handles edge cases, and produces reliable results.

A dense, opinionated style guide that respects the reader's intelligence, sequences its process explicitly (orient → decide → implement per-mode → verify), and names concrete APIs and code smells rather than abstractions. Its main gaps are cross-section redundancy, no worked code examples of its own modeling patterns, and no error-recovery loop in the verification workflow.

Suggestions

Add one compact before/after example of Constructive Domain Modeling (e.g., a status-string-plus-optional-fields dataclass converted to a closed union with a match consumer) — this is the skill's central pattern and is currently described only abstractly, which is the main driver of the actionability gap.

Deduplicate guidance that appears in multiple sections: consolidate Pydantic-at-boundaries into one place and let 'Make Decisions In This Order' be the single home for the smallest-abstraction rule, trimming roughly 10–15 lines.

Add an error-recovery note to 'Verify The Result' (e.g., 'if the type checker reports a non-exhaustive match, add the missing case rather than a catch-all') so the validation ladder has a feedback loop.

DimensionReasoningScore

Conciseness

The body assumes Claude's competence throughout — it names APIs ('typing.assert_never', 'functools.singledispatch', Python 3.12 'type' alias) without explaining what they are, and every line is a directive. It falls short of lean-and-efficient 5 because of redundancy across sections: Pydantic-at-boundaries guidance appears in both 'Model The Positive Space' and 'Write Explicit Python', and the smallest-abstraction rule is restated across 'Make Decisions In This Order', 'Prefer Functions Before Hierarchies', and 'Keep Reasoning Local'.

4 / 5

Actionability

As an instruction-only skill its guidance is concrete and specific: exact ordered decision rules, named constructs to use ('a closed union using a Python 3.12 type alias', 'typing.assert_never', 'frozen dataclass'), and concrete refactor smells to look for ('status strings coupled to optional fields, repeated validation, "should never happen" branches'). It misses fully-executable 5 because there are no worked before/after examples of the core modeling patterns, so applying them to real code still requires interpretation.

4 / 5

Workflow Clarity

Sequencing is explicit and ordered: 'Orient Before Coding' (5 numbered steps), 'Make Decisions In This Order' (6 ranked rules), mode-specific guidance (Write/Refactor/Review), and an escalating verification ladder ('Run the narrowest command that proves the change, then widen according to risk: focused tests → formatter/linter/type checker → repository gates'). It is not a 5 because checkpoints lack error-recovery feedback loops — nothing says what to do when verification fails — leaving minor validation gaps.

4 / 5

Progressive Disclosure

The ~140-line body is organized into clear, well-labeled sections (Orient, Decisions, Model, Functions, Locality, Explicit Python, Modes, Verify), and the only files it points to (AGENTS.md, docs/ENGINEERING_STYLE.md, docs/DOMAIN_MODEL.md) are target-repository files rather than bundle references; the sole scripts/ file (run_evals.py) is the eval harness and is never referenced by the body. Structure is good with minor gaps — the skill exceeds 50 lines and the mode-specific and pattern-catalog guidance could plausibly live in reference files — so it sits at anchor 4 rather than the well-split 5.

4 / 5

Total

16

/

20

Passed

Description

83%Weight 40%Scale 1-5

Based on the skill's description, can an agent find and select it at the right time? Clear, specific descriptions lead to better discovery.

A strong description: explicit third-person 'what' and a concrete multi-clause 'Use when' trigger set covering write/refactor/review modes. Keyword coverage is good and the voice is correct; it only lacks a few natural synonyms (.py, 'clean up') and carries one confusingly niche scope qualifier.

DimensionReasoningScore

Specificity

"Write, refactor, and review Python" names three concrete actions plus concrete quality targets ("strong types, constructive domain modeling, and minimal abstraction"), matching the anchor for several specific actions with minor gaps. It stops short of 5 because the actions stay high-level — no concrete techniques or operations are named (no counterpart to 'convert pages to images').

4 / 5

Completeness

It explicitly answers both questions: the 'what' is 'Write, refactor, and review Python for clarity, explicit behavior, local reasoning, strong types...' and the 'when' is a concrete multi-clause trigger: 'Use when creating or changing nontrivial Python, simplifying object-heavy, helper-heavy, or overly procedural code, evaluating whether code is Pythonic, or reviewing Python maintainability'. This matches the top anchor (clear what AND when with concrete trigger phrases), and a 'Use when' clause is present, so the 3-cap does not apply.

5 / 5

Trigger Term Quality

Natural user phrases are well covered: "creating or changing nontrivial Python", "simplifying object-heavy, helper-heavy, or overly procedural code", "evaluating whether code is Pythonic", and "reviewing Python maintainability". A few common terms are missing (.py files, 'clean up this code', framework names), so it sits at 'good keyword coverage; a few natural terms missing' rather than the comprehensive 5.

4 / 5

Distinctiveness Conflict Risk

The niche is clear (Python-specific style/maintainability with distinctive triggers like 'Pythonic' and 'object-heavy'), so it is mostly distinct. Minor overlap remains with general code-review and simplification skills, and the oddly narrow 'in Basic Memory repositories' qualifier narrows the stated review scope without adding a distinguishing trigger — so it does not reach the clear-niche, minimal-conflict 5.

4 / 5

Total

17

/

20

Passed

Validation

100%

Checks the skill against the spec for correct structure and formatting. All validation checks must pass before discovery and implementation can be scored.

Validation — 16 / 16 Passed

Validation for skill structure

No warnings or errors.

Repository

basicmachines-co/basic-memory

Path

.agents/skills/pythonic-code/SKILL.md

Reviewed

Table of Contents

Is this your skill?

If you maintain this skill, you can claim it as your own. Once claimed, you can manage eval scenarios, bundle related skills, attach documentation or rules, and ensure cross-agent compatibility.