Skip to content
Skills Library
Programming · Analysis

code-standards-adopter

/code-standards-adopter

Infers a codebase's implicit coding conventions (naming, structure, imports, comments, error handling) by analyzing the existing code, then makes them explicit: generates linter/formatter configs that match current reality, a conventions document, and agent steering rules so AI-written code blends in. Use when adopting AI coding tools on an existing codebase or onboarding to an unfamiliar team style. Triggers on: "match our coding style", "infer our conventions", "generate lint config from this codebase", "make the AI write code like our team", "extract our code standards", "set up steering ru

Licence
MIT
Last repository change
16.09.2026

Assessment and security

100/ 100Class: good
Format25 / 25
Frontmatter with name and description, valid name, description up to 1,024 characters, name matching the folder.
Discoverability25 / 25
Description explains when to use the skill, has a reasonable length and uses third person.
Content35 / 35
At least 150 words and at most 500 lines, headings, step lists, examples or code.
Hygiene15 / 15
No placeholders such as TODO, no Windows paths, with a licence.
Riskno signals detected in the scan
Files in this package
3
Scripts
0
HTML comments
0
URLs in SKILL.md
0
Deprecation

No signals detected. Repository changed on 16.09.2026, without references to retired models or APIs.

Licence

MIT, open: use and modify while retaining author attribution.

What it does and when to use it

Infers a codebase's implicit coding conventions (naming, structure, imports, comments, error handling) by analyzing the existing code, then makes them explicit: generates linter/formatter configs that match current reality, a conventions document, and agent steering rules so AI-written code blends in. Use when adopting AI coding tools on an existing codebase or onboarding to an unfamiliar team style. Triggers on: "match our coding style", "infer our conventions", "generate lint config from this codebase", "make the AI write code like our team", "extract our code standards", "set up steering ru

Triggers from the description

match our coding styleinfer our conventionsgenerate lint config from this codebasemake the AI write code like our teamextract our code standards
Original author description

Infers a codebase's implicit coding conventions (naming, structure, imports, comments, error handling) by analyzing the existing code, then makes them explicit: generates linter/formatter configs that match current reality, a conventions document, and agent steering rules so AI-written code blends in. Use when adopting AI coding tools on an existing codebase or onboarding to an unfamiliar team style. Triggers on: "match our coding style", "infer our conventions", "generate lint config from this codebase", "make the AI write code like our team", "extract our code standards", "set up steering ru

How it works

  1. Process
  2. Convention Checklist
  3. Steering Rules Quality Bar
  4. Guidelines
Original SKILL.md headings · 48 lines, 596 words
SKILL.md preview
---
name: code-standards-adopter
description: >
  Infers a codebase's implicit coding conventions (naming, structure, imports, comments, error
  handling) by analyzing the existing code, then makes them explicit: generates linter/formatter
  configs that match current reality, a conventions document, and agent steering rules so AI-written
  code blends in. Use when adopting AI coding tools on an existing codebase or onboarding to an
  unfamiliar team style. Triggers on: "match our coding style", "infer our conventions", "generate
  lint config from this codebase", "make the AI write code like our team", "extract our code
  standards", "set up steering rules from existing code".
license: MIT
metadata:
  author: Community
  version: 1.0.0
  category: engineering-workflow
---

# Code Standards Adopter

Most teams' real conventions live in the code, not in a style guide. This skill reads the codebase, infers the conventions actually in force, and turns them into enforceable artifacts — so newly written code (human or AI) matches what's already there instead of fighting it.

The output is descriptive first, prescriptive second: capture what IS, flag inconsistencies, and let the team decide what SHOULD be.

## Process

1. **Sample the codebase.** Don't read everything. Pick 10-20 representative files: the most-recently-changed files (current style), the largest modules (dominant style), and one file per major directory. Note the languages and frameworks in play.
2. **Infer conventions per dimension** (see checklist below). For each, record: the dominant pattern, observed frequency (e.g. "camelCase in 18/20 files"), and exceptions worth flagging.
3. **Detect existing enforcement.** Check for linter/formatter configs (.eslintrc, ruff.toml, .editorconfig, checkstyle, prettier, gofmt assumptions), CI lint steps, and pre-commit hooks. Never generate a config that conflicts with one that exists — propose amendments instead.
4. **Generate the artifacts** the user needs (ask if unclear, default to all three):
   - **Conventions document** — concise markdown, one section per dimension, with real examples lifted from the codebase (anonymized if sensitive).
   - **Tool configs** — linter/formatter configuration matching the inferred style, with each non-default rule commented with its evidence ("18/20 files use single quotes").
   - **Agent steering rules** — a steering/context file for AI coding tools (Kiro `.kiro/steering/code-style.md`, CLAUDE.md section, or equivalent) containing only the conventions an agent would otherwise get wrong.
5. **Report inconsistencies separately.** Where the codebase splits (e.g. two naming styles 60/40), present both options with counts and let the team pick — do not silently impose the majority.

## Convention Checklist

| Dimension | What to look for |
|-----------|------------------|
| Naming | Case styles per identifier kind (files, classes, functions, constants, DB columns); abbreviation habits; test file naming |
| Structure | Directory layout logic; one-class-per-file or not; where interfaces/types live; co-location of tests |
| Imports | Ordering and grouping; absolute vs relative; barrel files; aliasing |
| Functions | Typical length; early-return vs nested; parameter object thresholds |
| Errors | Exceptions vs result types; error wrapping; logging at throw site or boundary; custom error classes |
| Comments | Density; docstring format and coverage; TODO conventions; license headers |
| Tests | Framework idioms; naming (`should_x` vs `test_x` vs `it('...')`); fixture patterns; assertion style |
| Formatting | Quotes, semicolons, line length, trailing commas — only where no formatter already decides |
| Git | Commit message style; branch naming (read recent history) |

## Steering Rules Quality Bar

The steering file is the highest-leverage artifact. Keep it under ~50 lines:

- Include only conventions a competent agent would plausibly get wrong (project-specific idioms, unusual choices, the chosen side of any inconsistency).
- Exclude anything a formatter/linter already enforces — tools enforce, steering informs.
- One example per rule, drawn from the actual codebase.
- State the why where it isn't obvious ("we use result types because exceptions cross a WASM boundary here").

## Guidelines

- Evidence over taste: every rule you emit must cite observed frequency. If you can't count it, don't claim it.
- Respect the formatter hierarchy: if prettier/gofmt/black is present, formatting dimensions are settled — don't relitigate them in the conventions doc.
- For polyglot repos, produce per-language sections; don't average conventions across languages.
- If the codebase is too small (<10 source files) or too inconsistent to infer anything, say so and recommend starting from a community standard instead, listing what was actually observed.
Files in this package (3)
  • SKILL.md 5 KB
  • evals/evals.json 2 KB
  • evals/trigger_evals.json 2 KB

Versions

The database has no other skills named code-standards-adopter.

Database snapshot: 13.11.2026 · package version 2c41c1bd40bf (SHA-256 digest of the entire package)

Downloads in the last 30 days: 0 · ranking

Report a problem with this skill: harmful content, incorrect descriptions or an author’s removal request.

Similar skills

  • 100conventions
    Act as keyturn's standards role. Turn a project's design document (and its stack profile, when one exists) into tool rules that run in the gate, such as formatter and linter configs, complexity limits, boundaries between parts, and custom static-analysis rules, and write…
  • 100project-conventions
    Guides discovery and application of project-specific conventions including code patterns, naming, structure, and team practices. Use when exploring a codebase or implementing features to match existing patterns.
  • 100project-conventions
    Guides discovery and application of project-specific conventions including code patterns, naming, structure, and team practices. Use when exploring a codebase or implementing features to match existing patterns.
  • 100conventions
    Scaffold or update docs/CONVENTIONS.md by reading the actual codebase and interviewing the user. Use when setting up a new project or when conventions have drifted and need to be documented. Trigger this when someone says: document our team standards, set up conventions, what…
  • 90re0-style
    Fix code in a named change or file list so it matches the conventions its own repository already keeps: run the project's configured formatter and linter in fix mode through the project's own toolchain, then fix by hand what no tool decides (naming, import order, file layout,…
  • 100style-guide
    Analyze a codebase to extract its conventions, patterns, and style. Spawns specialized analyzer agents that each focus on one aspect (structure, naming, patterns, testing, frontend). Generates a comprehensive style guide that other skills can reference. Use when starting work on…

Feedback and reports

Your message goes to Bartosz Sokoliński. An email address is needed only for a reply. See the privacy policy.