# Ultracite for Qwen Code

Use Ultracite with Qwen Code when you want a coding-focused CLI to move quickly without abandoning the repo standards your team depends on. It is a good fit for rapid iteration, natural-language tasking, and terminal-heavy development.

## Setup details

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

### AGENTS.md

Run `npx ultracite@latest init --agents qwen` 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

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

Qwen Code does not use a separate hook configuration in Ultracite.

## Files Ultracite writes for Qwen Code

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

### Markdown AGENTS.md

```
# 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 Qwen Code, based on how the agent reads instructions and how teams typically wire it into day-to-day development.

1. Fast terminal iteration

Keep Qwen Code aligned while you move quickly from prompt to patch and refine the result in the shell.

2. Natural-language tasking

Use a committed repo contract so broad natural-language requests still produce code that fits the project.

3. Portable agent setup

Reuse the same AGENTS.md pattern across repos where Qwen Code needs explicit project expectations.

## Why this setup works for Qwen Code

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

- Coder-focused CLI

Qwen Code is built around agentic coding from natural language, so repo standards help focus that flexibility into consistent implementation decisions.

- Portable AGENTS.md setup

The integration uses a shared repo file that is easy to commit, review, and reuse across projects.

- Useful for rapid iteration

Ultracite helps Qwen Code stay consistent during fast prompt-to-code loops where output quality can otherwise vary widely.

## Install in seconds. Run in milliseconds.

Install Ultracite and start shipping code faster in seconds.

$