Ultracite for Aider

Use Ultracite with Aider when you want terminal pair programming to stay aligned with the same repo rules you expect from direct edits. It is a natural fit for patch-based workflows, quick iterations, and developer-in-the-loop collaboration.

$

Setup details

These values come from the same data Ultracite uses when it creates or updates Aider instructions, so the page matches what actually gets written into the repo.

Run npx ultracite@latest init --agents aider and Ultracite will update this file for the default setup.

Configuration file

Ultracite writes to this exact file when you initialize or update the agent integration.

Write mode

Replace with a fresh rules file

Ultracite writes a fresh rules file so the agent starts from a clean, predictable baseline.

Header handling

Writes rules directly

The generated file starts directly with Ultracite rules and skips an extra heading block.

Hook support

No separate hook file

Aider does not use a separate hook configuration in Ultracite.

Files Ultracite writes for Aider

This preview shows the exact default file content Ultracite writes for Aider when you use the standard Biome setup.

Ultracite Code Standards

This project uses Ultracite, a zero-config preset that enforces strict code quality standards through automated formatting and linting.

Quick Reference

  • Format code: npx ultracite fix
  • Check for issues: npx ultracite check
  • Diagnose setup: npx ultracite doctor

Biome (the underlying engine) provides robust linting and formatting. Most issues are automatically fixable.

Core Principles

Write code that is accessible, performant, type-safe, and maintainable. Focus on clarity and explicit intent over brevity.

Type Safety & Explicitness

  • Use explicit types for function parameters and return values when they enhance clarity.
  • Prefer unknown over any when the type is genuinely unknown.
  • Use const assertions (as const) for immutable values and literal types.
  • Leverage TypeScript's type narrowing instead of type assertions.
  • Use meaningful variable names instead of magic numbers - extract constants with descriptive names.

Modern JavaScript/TypeScript

  • Use arrow functions for callbacks and short functions.
  • Prefer for...of loops over .forEach() and indexed for loops.
  • Use optional chaining (?.) and nullish coalescing (??) for safer property access.
  • Prefer template literals over string concatenation.
  • Use destructuring for object and array assignments.
  • Use const by default, let only when reassignment is needed, never var.

Async & Promises

  • Always await promises in async functions - don't forget to use the return value.
  • Use async/await syntax instead of promise chains for better readability.
  • Handle errors appropriately in async code with try-catch blocks.
  • Don't use async functions as Promise executors.

React & JSX

  • Use function components over class components.
  • Call hooks at the top level only, never conditionally.
  • Specify all dependencies in hook dependency arrays correctly.
  • Use the key prop for elements in iterables (prefer unique IDs over array indices).
  • Nest children between opening and closing tags instead of passing as props.
  • Don't define components inside other components.
  • Use semantic HTML and ARIA attributes for accessibility:
    • Provide meaningful alt text for images
    • Use proper heading hierarchy
    • Add labels for form inputs
    • Include keyboard event handlers alongside mouse events
    • Use semantic elements (<button>, <nav>, etc.) instead of divs with roles.

Error Handling & Debugging

  • Remove console.log, debugger, and alert statements from production code.
  • Throw Error objects with descriptive messages, not strings or other values.
  • Use try-catch blocks meaningfully - don't catch errors just to rethrow them.
  • Prefer early returns over nested conditionals for error cases.

Code Organization

  • Keep functions focused and under reasonable cognitive complexity limits.
  • Extract complex conditions into well-named boolean variables.
  • Use early returns to reduce nesting.
  • Prefer simple conditionals over nested ternary operators.
  • Group related code together and separate concerns.

Security

  • Add rel="noopener" when using target="_blank" on links.
  • Avoid dangerouslySetInnerHTML unless absolutely necessary.
  • Don't use eval() or assign directly to document.cookie.
  • Validate and sanitize user input.

Performance

  • Avoid spread syntax in accumulators within loops.
  • Use top-level regex literals instead of creating them in loops.
  • Prefer specific imports over namespace imports.
  • Avoid barrel files (index files that re-export everything).
  • Use proper image components (e.g., Next.js <Image>) over <img> tags.

Framework-Specific Guidance

Next.js:

  • Use Next.js <Image> component for images.
  • Use next/head or App Router metadata API for head elements.
  • Use Server Components for async data fetching instead of async Client Components.

React 19+:

  • Use ref as a prop instead of React.forwardRef.

Solid/Svelte/Vue/Qwik:

  • Use class and for attributes (not className or htmlFor).

Testing

  • Write assertions inside it() or test() blocks.
  • Avoid done callbacks in async tests - use async/await instead.
  • Don't use .only or .skip in committed code.
  • Keep test suites reasonably flat - avoid excessive describe nesting.

When Biome Can't Help

Biome's linter will catch most issues automatically. Focus your attention on:

  1. Business logic correctness - Biome can't validate your algorithms.
  2. Meaningful naming - Use descriptive names for functions, variables, and types.
  3. Architecture decisions - Component structure, data flow, and API design.
  4. Edge cases - Handle boundary conditions and error states.
  5. User experience - Accessibility, performance, and usability considerations.
  6. Documentation - Add comments for complex logic, but prefer self-documenting code.

Most formatting and common issues are automatically fixed by Biome. Run npx ultracite fix before committing to ensure compliance.

Best for

These are the workflows where Ultracite adds the most leverage to Aider, based on how the agent reads instructions and how teams typically wire it into day-to-day development.

  1. Tight edit-review loops. Keep Aider aligned while you iterate quickly on a fix, inspect the patch, and ask for the next change.

  2. Git-centric workflows. Use a dedicated rules file when Aider is operating close to commits, diffs, and staged changes.

  3. Solo developer pair programming. Give Aider a persistent repo contract so it behaves consistently across multiple terminal sessions.

Why this setup works for Aider

These differentiators come from the way Aider actually handles repo instructions, file updates, and AI-assisted development work.

Pair-programming cadence

Aider is conversational and iterative, so a single dedicated rules file helps every back-and-forth stay grounded in the same standards.

Dedicated config path

Aider uses ultracite.md, which gives the integration a focused file rather than a shared AGENTS.md document.

Works well with git-driven edits

Ultracite is useful when Aider is applying patches, staging changes, and iterating quickly against a repo's real history.

Install in seconds. Run in milliseconds.

Install Ultracite and start shipping code faster in seconds.

$