UltraciteUltracite
Read the docs
UltraciteVercel Agent

Ultracite for Vercel Agent

Use Ultracite with Vercel Agent when you want cloud-connected coding tasks to follow the same repo standards you apply before code reaches production. It is a strong fit for teams building inside the Vercel ecosystem and shipping through fast feedback loops.

$

Setup details

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

AGENTS.md

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

Configuration file
AGENTS.md

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

Write mode
Append to existing instructions

Existing instructions stay in place and Ultracite appends its rules where the agent expects them.

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

Vercel Agent does not use a separate hook configuration in Ultracite.

Files Ultracite writes for Vercel Agent

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

If Vercel Agent supports hooks, the second tab shows the companion hook config that runs after AI-driven edits.

# Ultracite Code StandardsThis 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 PrinciplesWrite 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 HelpBiome's linter will catch most issues automatically. Focus your attention on:1. **Business logic correctness** - Biome can't validate your algorithms2. **Meaningful naming** - Use descriptive names for functions, variables, and types3. **Architecture decisions** - Component structure, data flow, and API design4. **Edge cases** - Handle boundary conditions and error states5. **User experience** - Accessibility, performance, and usability considerations6. **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 Vercel Agent, based on how the agent reads instructions and how teams typically wire it into day-to-day development.

01

Production-minded feature work

Keep Vercel Agent aligned when code changes are likely to move quickly from implementation into deployment workflows.

02

Platform-centric teams

Use one committed AGENTS.md file so every repo in a Vercel-heavy stack shares the same coding contract.

03

Fast feedback loops

Reduce cleanup after AI-generated changes by making standards explicit before the work reaches preview or production environments.

Why this setup works for Vercel Agent

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

Vercel ecosystem alignment

Vercel Agent sits inside a broader deployment and platform workflow, so committed repo rules help keep AI output aligned with production expectations.

Simple AGENTS.md adoption

The integration uses a portable repo file that is easy to review, version, and share across services.

Helpful for platform-connected tasks

Ultracite gives Vercel Agent a stable coding contract before it works on features that may later interact with deployment, routing, or runtime concerns.

Trusted by top companies

And used by thousands of open source projects.

Vercel
Profound
Adobe
Clerk
Alan Turing Institute
Consent
VA
French Government
Tencent
Posthog
Axiom
Resend
Redpanda
Workday
ElevenLabs
Mintlify
Sentry
Raycast
Moonshot
Augment Code

What the community is saying

Here's what some of the most innovative and forward-thinking developers in the React ecosystem have to say about Ultracite.

Install in seconds. Run in milliseconds.

Install Ultracite and start shipping code faster in seconds.

$