Skip to main content
skill CX Codex

code-formatter-installer — Claude Code skill: Prettier, ESLint, hooks

code-formatter-installer installs Prettier, ESLint, EditorConfig and git hooks, then wires them into CI so the whole team formats code the same way.

MIT 278 installs ★ 64 updated 2026-01-12

Install into Claude Code · Skills CLI (Vercel) All methods and platforms ↓
npx skills add patricio0312rev/skills --skill code-formatter-installer -a claude-code
Open on GitHub

What code-formatter-installer does

The skill runs the whole setup in one pass. It works out which language the project uses, picks a formatter and a linter, writes the config files, adds package scripts, editor settings, a git hook and a CI step. JavaScript and TypeScript get Prettier with ESLint and typescript-eslint. Python gets Black and isort with Ruff or Flake8 plus mypy, Go gets gofmt and golangci-lint, Rust gets rustfmt and clippy.

Templates ship with the skill: .prettierrc.json at printWidth 100 with single quotes, .eslintrc.json where no-console only warns, an .editorconfig with two-space indent and lf endings, and a [tool.black] block for pyproject.toml. The scripts cover format, format:check, lint, lint:fix and typecheck; Husky with lint-staged handles Node.js. Ready-made sets for Next.js, React, Node.js, FastAPI and Django sit in assets/configs/.

In a Python repo the hook stays inactive until pre-commit install runs, so pip install pre-commit on its own is not enough. The author keeps an escape hatch with git commit --no-verify and asks that the team write down when that is acceptable.

What it helps with

  • set up Prettier and ESLint in a TypeScript repo without hand-picking rules
  • generate an .editorconfig that does not fight the formatter
  • run the formatter on changed files only before each commit
  • add a format:check job to CI so unformatted code fails the build
  • wire Black, isort and mypy into pyproject.toml

Example prompts for the agent

  • Set up Prettier and ESLint for this repo, put the configs in the root and add format and lint scripts.
  • Add a pre-commit hook that runs eslint --fix and prettier --write on staged files with Husky and lint-staged.
  • Write .github/workflows/lint.yml that checks formatting and types on every push.

How to install code-formatter-installer

1Skills CLI (Vercel)

npx skills add patricio0312rev/skills --skill code-formatter-installer -a claude-code

2Manually: put the files in place

~/.claude/skills/code-formatter-installer/SKILL.md

Copy the whole skill folder; for one project use .claude/skills/code-formatter-installer/

Step by step, with commands for each platform: How to install skills in Claude Code: five ways

Questions about code-formatter-installer

How do I install code-formatter-installer in Claude Code?

Run npx skills add patricio0312rev/skills --skill code-formatter-installer -a claude-code. The skill file lands at ~/.claude/skills/code-formatter-installer/SKILL.md.

What does code-formatter-installer do?

It detects the project stack, picks a formatter and a linter, writes the configs and adds scripts, editor settings, a git hook and a CI step.

Does it handle Python projects?

Yes. It sets up Black, isort and Ruff or Flake8 with mypy, fills the pyproject.toml blocks and adds a .pre-commit-config.yaml. The hook starts working after pre-commit install.

Source text

SKILL.md · MIT
---
name: code-formatter-installer
description: Installs and configures Prettier, ESLint, EditorConfig, and other code quality tools to enforce consistent code style across the team. Generates config files, npm scripts, editor settings recommendations, and CI integration suggestions. Use when users request "setup prettier", "add eslint", "configure code formatting", or "enforce code style".
---

# Code Formatter & Linter Installer

Establish consistent code formatting and linting across your project.

## Core Workflow

1. **Detect stack**: Identify language/framework (JS/TS, Python, Go, Rust)
2. **Choose tools**: Select appropriate formatters and linters
3. **Generate configs**: Create config files with best-practice rules
4. **Add scripts**: Include npm/package scripts for format/lint
5. **Configure editor**: Provide VS Code, IntelliJ, Vim settings
6. **Setup pre-commit**: Add git hooks for automatic formatting
7. **CI integration**: Suggest GitHub Actions or CI config

## Tool Selection by Stack

### JavaScript/TypeScript

- **Formatter**: Prettier
- **Linter**: ESLint + typescript-eslint
- **Editor**: EditorConfig
- **Hooks**: Husky + lint-staged

### Python

- **Formatter**: Black + isort
- **Linter**: Ruff or Flake8 + mypy
- **Hooks**: pre-commit

### Go

- **Formatter**: gofmt + goimports
- **Linter**: golangci-lint

### Rust

- **Formatter**: rustfmt
- **Linter**: clippy

## Configuration Templates

### Prettier (.prettierrc.json)

```json
{
  "semi": true,
  "trailingComma": "es5",
  "singleQuote": true,
  "printWidth": 100,
  "tabWidth": 2,
  "arrowParens": "avoid"
}
```

### ESLint (.eslintrc.json)

```json
{
  "extends": [
    "eslint:recommended",
    "plugin:@typescript-eslint/recommended",
    "plugin:react/recommended",
    "prettier"
  ],
  "rules": {
    "no-console": "warn",
    "@typescript-eslint/no-unused-vars": "error"
  }
}
```

### EditorConfig (.editorconfig)

```ini
root = true

[*]
indent_style = space
indent_size = 2
end_of_line = lf
charset = utf-8
trim_trailing_whitespace = true
insert_final_newline = true

[*.py]
indent_size = 4

[*.md]
trim_trailing_whitespace = false
```

### Python (pyproject.toml)

```toml
[tool.black]
line-length = 100
target-version = ['py311']

[tool.isort]
profile = "black"
line_length = 100

[tool.mypy]
strict = true
warn_return_any = true
```

## Package Scripts

### JavaScript/TypeScript (package.json)

```json
{
  "scripts": {
    "format": "prettier --write .",
    "format:check": "prettier --check .",
    "lint": "eslint . --ext .ts,.tsx,.js,.jsx",
    "lint:fix": "eslint . --ext .ts,.tsx,.js,.jsx --fix",
    "typecheck": "tsc --noEmit"
  }
}
```

### Python

```bash
# Makefile or scripts
format:
	black .
	isort .

lint:
	ruff check .
	mypy .

format-check:
	black --check .
	isort --check .
```

## Git Hooks Setup

### Husky + lint-staged (Node.js)

1. Install dependencies:

```bash
npm install --save-dev husky lint-staged
npx husky init
```

2. Configure lint-staged (.lintstagedrc.json):

```json
{
  "*.{ts,tsx,js,jsx}": ["eslint --fix", "prettier --write"],
  "*.{json,md,yml}": ["prettier --write"]
}
```

3. Add pre-commit hook (.husky/pre-commit):

```bash
#!/bin/sh
npx lint-staged
```

### pre-commit (Python)

1. Create .pre-commit-config.yaml:

```yaml
repos:
  - repo: https://github.com/psf/black
    rev: 24.1.1
    hooks:
      - id: black

  - repo: https://github.com/pycqa/isort
    rev: 5.13.2
    hooks:
      - id: isort

  - repo: https://github.com/astral-sh/ruff-pre-commit
    rev: v0.2.0
    hooks:
      - id: ruff
        args: [--fix]

  - repo: https://github.com/pre-commit/mirrors-mypy
    rev: v1.8.0
    hooks:
      - id: mypy
```

2. Install:

```bash
pip install pre-commit
pre-commit install
```

## Editor Configuration

### VS Code (settings.json)

```json
{
  "editor.defaultFormatter": "esbenp.prettier-vscode",
  "editor.formatOnSave": true,
  "editor.codeActionsOnSave": {
    "source.fixAll.eslint": true
  },
  "[python]": {
    "editor.defaultFormatter": "ms-python.black-formatter"
  }
}
```

### VS Code Extensions (.vscode/extensions.json)

```json
{
  "recommendations": [
    "esbenp.prettier-vscode",
    "dbaeumer.vscode-eslint",
    "editorconfig.editorconfig",
    "ms-python.black-formatter"
  ]
}
```

### IntelliJ/WebStorm

- Enable: Settings → Languages & Frameworks → JavaScript → Prettier → On save
- Enable: Settings → Tools → Actions on Save → Reformat code

## CI Integration

### GitHub Actions (.github/workflows/lint.yml)

```yaml
name: Lint

on: [push, pull_request]

jobs:
  lint:
    runs-on: ubuntu-latest
    steps:
      - uses: actions/checkout@v4
      - uses: actions/setup-node@v4
        with:
          node-version: 20
      - run: npm ci
      - run: npm run format:check
      - run: npm run lint
      - run: npm run typecheck
```

### Pre-merge checks

```yaml
# .github/workflows/pr-checks.yml
- name: Check formatting
  run: |
    npm run format:check || {
      echo "Code is not formatted. Run 'npm run format' locally."
      exit 1
    }
```

## Installation Checklist

For every setup, provide:

- [ ] Config files (.prettierrc, .eslintrc, .editorconfig, etc.)
- [ ] Ignore files (.prettierignore, .eslintignore)
- [ ] Package scripts (format, lint, format:check, lint:fix)
- [ ] Git hooks (husky/pre-commit)
- [ ] Editor settings (.vscode/settings.json)
- [ ] CI workflow (.github/workflows/lint.yml)
- [ ] Documentation (README section on running lint/format)

## Best Practices

1. **Run formatter last**: Prettier should override other formatting rules
2. **Extend configs**: Use popular presets (Airbnb, Standard, etc.)
3. **Ignore generated files**: Add build outputs to ignore files
4. **Make hooks skippable**: Allow `git commit --no-verify` for emergencies
5. **Document process**: Add "Code Style" section to CONTRIBUTING.md
6. **Test on clean install**: Ensure configs work without local editor setup
7. **Keep rules minimal**: Start strict, relax if needed

## Common Configurations

See `assets/configs/` for ready-to-use config files:

- Next.js + TypeScript
- React + TypeScript
- Node.js + TypeScript
- Python FastAPI
- Python Django

## Bypass Instructions (Emergencies)

```bash
# Skip pre-commit hooks
git commit --no-verify

# Skip CI checks (not recommended)
git push --no-verify
```

Document when bypass is acceptable (hotfixes, emergencies only).

© patricio0312rev · MIT · patricio0312rev/skills

Similar skills

All skills for Agent setup: memory, context, orchestration →

From the same set148

The whole set →
flaky-test-detective The flaky-test-detective skill traces intermittent test failures to timing, state, random data, or network calls. Use it when a test passes and fails across runs. CX Codex +1 283installs monorepo-setup monorepo-setup lays out a Turborepo and pnpm monorepo: apps, shared packages, TypeScript and ESLint configs, and a build pipeline. CX Codex +1 283installs typescript-strict-migrator typescript-strict-migrator moves a TypeScript codebase to strict mode one compiler flag at a time: audit the errors, then turn on noImplicitAny, strictNullChecks and the rest. Handy when strict: true throws too much at once. CX Codex +1 280installs migration-planner migration-planner turns a database or platform move into ordered phases with feature flags, dual writes, backfill and checks, plus a way back from each step. CX Codex +1 279installs caching-strategist caching-strategist turns a vague “add caching” request into named layers, key layouts, TTL values and invalidation rules, with TypeScript samples for Redis and CDN. CX Codex +1 278installs rest-to-graphql-migrator rest-to-graphql-migrator — a skill that walks a REST API over to GraphQL one endpoint at a time, wrapping existing routes instead of rebuilding the backend. CX Codex +1 277installs insomnia-collection-generator insomnia-collection-generator scans Express, Fastify, and Next.js routes to generate an Insomnia v4 collection export file with organized workspaces, folders, and environments. CX Codex +1 277installs security-pr-checklist-skill security-pr-checklist-skill builds a repeatable security checklist for pull requests. Use it to structure code reviews, required checks, and CI security gates. CX Codex +1 276installs

Project sponsors

Companies that keep this analytics open