coding-style
Coding style, testing, and PR guidelines for the Kubb ecosystem. Use when writing or reviewing code for the Kubb ecosystem.
Best use case
coding-style is best used when you need a repeatable AI agent workflow instead of a one-off prompt.
Coding style, testing, and PR guidelines for the Kubb ecosystem. Use when writing or reviewing code for the Kubb ecosystem.
Teams using coding-style should expect a more consistent output, faster repeated execution, less prompt rewriting.
When to use this skill
- You want a reusable workflow that can be run more than once with consistent structure.
When not to use this skill
- You only need a quick one-off answer and do not need a reusable workflow.
- You cannot install or maintain the underlying files, dependencies, or repository context.
Installation
Claude Code / Cursor / Codex
Manual Installation
- Download SKILL.md from GitHub
- Place it in
.claude/skills/coding-style/SKILL.mdinside your project - Restart your AI agent — it will auto-discover the skill
How coding-style Compares
| Feature / Agent | coding-style | Standard Approach |
|---|---|---|
| Platform Support | Not specified | Limited / Varies |
| Context Awareness | High | Baseline |
| Installation Complexity | Unknown | N/A |
Frequently Asked Questions
What does this skill do?
Coding style, testing, and PR guidelines for the Kubb ecosystem. Use when writing or reviewing code for the Kubb ecosystem.
Where can I find the source code?
You can find the source code on GitHub using the link provided at the top of the page.
Related Guides
AI Agents for Coding
Browse AI agent skills for coding, debugging, testing, refactoring, code review, and developer workflows across Claude, Cursor, and Codex.
Cursor vs Codex for AI Workflows
Compare Cursor and Codex for AI coding workflows, repository assistance, debugging, refactoring, and reusable developer skills.
SKILL.md Source
# Code Style and Testing Skill ## When to Use - When creating or reviewing a PR that changes code - When adding a new package or feature to the monorepo - When updating CI, linting, or formatting configuration - When onboarding new contributors and sharing repository conventions ## What It Does This skill documents the repository's coding conventions, testing guidelines, and PR checklist so contributors and automation can produce consistent, high-quality changes. - Defines formatting, linting, and TypeScript conventions - Describes testing workflow and CI expectations - Outlines PR requirements, changelog updates, and release-related steps - Provides common troubleshooting and recovery commands ## How to Use Run the basic developer checks and fixes locally before committing or opening a PR: ```bash # Format code and attempt autofixes pnpm run format # Lint the repository pnpm run lint # Run unit tests pnpm test # Create a changeset for versioning pnpm changeset # Typecheck whole repo pnpm typecheck ``` Follow the PR checklist and run the commands above in the same order: **format → lint → typecheck → test → changeset**. ## Repository Facts - **Monorepo**: Managed by pnpm workspaces and Turborepo - **Module system**: ESM-only (`type: "module"` across repo) - **Node version**: 20 - **Testing Library**: Vitest - **Versioning**: Changesets for versioning and publishing - **CI/CD**: GitHub Actions ## Coding Style Guidelines ### Basic Rules - **Quotes**: Single quotes, no semicolons (see `biome.json`) - **Patterns**: Prefer functional patterns - **Ternary operators**: Keep ternary operators to one level deep for readability. For nested conditions, use if/else statements or extract to a helper function. ### Naming Conventions | Element / Context | Naming convention | | ----------------------: | :---------------- | | File / directory names | `camelCase` | | Variables / functions | `camelCase` | | Types / Interfaces | `PascalCase` | | React components | `PascalCase` | ### TypeScript Conventions - **Module resolution**: `"bundler"`; ESM only - **Strict typing**: NEVER use `any` type or `as any` casts. Always use proper types, generics, or `unknown`/`never` when appropriate. - **Files**: `.ts` for libraries, `.tsx` for React components, `.vue` for Vue components - **DTS output**: Managed by `tsdown` - **Importing**: Always use proper import statements at the module level instead of inline type imports - **Exporting**: use `"exports"` map and `typesVersions` as needed. Keep public API stable - **Root level types**: Define types at the root level of the file, not inside functions - **Function syntax in Objects**: Use function syntax (not arrow functions) in object methods to enable use of `this` keyword ## Testing - **Test location**: `*.test.ts` or `*.test.tsx` in `src` folders - **Focus on specific tests**: `pnpm test "<test name>"` - **Always add or update tests for code changes** and when needed update snapshots with the `-u` flag - **Fix all test and type errors until suite is green** - **After moving files or changing imports**: Run `pnpm lint && pnpm typecheck` ### Writing Conventions - **Focused**: Test one thing at a time - **Isolated**: Don't depend on other tests - **Repeatable**: Same results every time - **Fast**: Keep tests quick - **Clear**: Easy to understand what's being tested ## PR Instructions Follow these steps when creating a PR: 1. Make sure that the following commands pass locally: - `pnpm format && pnpm lint` - `pnpm typecheck` - `pnpm test` 2. Create a git commit with **Title format**: `[<plugin-name>] <Title>` 3. Push your branch and open a PR against `main` 4. Fill out the PR template completely 5. Add a changeset using `pnpm changeset` 6. Request reviews from relevant maintainers 7. Address feedback and make any requested changes 8. Once approved, wait for CI to pass and merge the PR ## Related Skills | Skill | Use For | |-----------------------------------------|---------------------| | **[../changelog/SKILL.md](../changelog/SKILL.md)** | Update changelogs, **Mandatory for all PRs that include code changes** |
Related Skills
dev-coding
Implement features as a Principal Engineering Developer
coding-standards
Provides coding standards for React Native — performance patterns, consistency rules, and clean React architecture. Use when writing, modifying, or reviewing code.
coding-principles
Language-agnostic coding principles for maintainability, readability, and quality. Use when implementing features, refactoring code, or reviewing code quality.
coding-lead
Smart coding skill that routes tasks by complexity. Simple tasks (<60 lines, single file) execute directly via OpenClaw agent tools. Medium/complex tasks spawn Claude Code via ACP with full project context, coding standards, and historical decisions from agent memory. Use when user asks to write code, fix bugs, build features, refactor, review PRs, deploy, or any software engineering task. Combines OpenClaw long-term memory with Claude Code deep coding ability.
coding-kotlin
Kotlin: coroutines, data classes, sealed classes, extension functions, Gradle, KMM multiplatform
checkstyle-rules
Use when applying Checkstyle built-in checks for Java code including naming conventions, code metrics, and suppressions.
cc-skill-coding-standards
Universal coding standards, best practices, and patterns for TypeScript, JavaScript, React, and Node.js development.
button-styles
Sistema de estilos de botones consistentes para iqEngi (Cards, CTAs, Formularios)
backend-coding
Expert backend development guidance covering Node.js, Python, Java, Go, API design (REST/GraphQL/gRPC), database patterns, authentication, caching, message queues, microservices, and testing. Produces production-ready, scalable, and secure backend code with industry best practices. Use when building APIs, implementing business logic, designing data models, integrating services, or when users mention backend development, server-side code, APIs, databases, or microservices.
1k-coding-patterns
Coding patterns and best practices for OneKey development. Use when writing React components, handling promises, error handling, or following code conventions. Triggers on react, component, hooks, promise, async, await, error, pattern, convention, typescript.
ui-design-styles
Comprehensive guidance for applying modern UI design styles, including Soft UI, Dark Mode, Flat Design, Neumorphism, Glassmorphism, and Aurora UI Gradients. Use when a user asks to: (1) Apply a specific UI style to a project, (2) Create a modern, visually appealing UI prototype, (3) Improve accessibility while following design trends, or (4) Understand the technical implementation of specific UI effects like frosted glass or soft shadows.
tool-design-style-selector
Use when you need to define or converge a project's visual direction. Scan project documentation to identify intent, then produce a design-system.md (either preserve existing style or pick from 30 presets). Triggers: design system, design spec, UI style, visual style, design tokens, color palette, typography, layout. Flow: scan → intent → (gate) preserve vs preset → deploy design-system.md after confirmation → (default) implement UI/UX per design-system.md (plan first, then execute).