> ## Documentation Index
> Fetch the complete documentation index at: https://docs.devin.ai/llms.txt
> Use this file to discover all available pages before exploring further.
# Regole e AGENTS.md
> Fornisci istruzioni e contesto sempre attivi che guidano l'agente in ogni sessione
Le regole sono istruzioni persistenti che determinano il comportamento di Devin CLI nel tuo progetto. Vengono inserite nel contesto dell'agente all'inizio di ogni sessione, garantendo un comportamento coerente all'interno del team.
Tra gli usi più comuni delle regole rientrano standard di codifica, linee guida architetturali, librerie preferite, convenzioni di testing e vincoli specifici del progetto.
**Per migliorare la capacità di scrivere codice, aumentare la velocità di completamento e ridurre i costi**, consigliamo vivamente di **usare invece le Skills quando possibile**. Le Skills vengono inserite nel contesto solo quando sono pertinenti. **Rules e AGENTS dovrebbero essere mantenuti il più brevi possibile.**
**Lo schema che consigliamo** è usare una regola per fare riferimento alle Skills che il modello dovrebbe usare in scenari specifici.
***
## AGENTS.md
Il modo più semplice per aggiungere regole è usare un file `AGENTS.md` nella directory principale del progetto:
```markdown theme={null}
# Regole del progetto
- Usa TypeScript per tutti i nuovi file
- Segui i patterns esistenti in src/components/
- Esegui sempre `npm run lint` prima di fare commit
- Usa pnpm, non npm o yarn
- Scrivi test per tutte le nuove funzioni utility
```
Devin CLI legge automaticamente questo file.
`AGENTS.md` è il metodo consigliato per le regole del progetto. È facile da leggere, sottoposto a controllo di versione e funziona con diversi strumenti di IA.
***
## Regole globali
Puoi anche creare regole che si applicano a **tutti i progetti** inserendo un file `AGENTS.md` nella directory di configurazione utente:
```
~/.config/devin/AGENTS.md
```
```
%APPDATA%\devin\AGENTS.md
```
Le regole globali vengono caricate all'inizio di ogni sessione, indipendentemente dal progetto su cui stai lavorando. Usale per preferenze personali valide ovunque:
```markdown theme={null}
# My Global Rules
- Always write commit messages in conventional commit format
- Prefer functional patterns over imperative code
- Run tests before suggesting a task is complete
```
Le regole globali funzionano insieme alle regole di progetto: entrambe vengono caricate e restano attive contemporaneamente. Anche `AGENT.md` è supportato in questo percorso.
Se usi Claude Code, Devin CLI legge anche `~/.claude/CLAUDE.md` come regola globale.
***
## Regole personali con AGENTS.local.md
Se hai istruzioni personali che non dovrebbero essere condivise con i collaboratori — come il tuo stile di lavoro preferito, le abitudini di testing o le preferenze per la revisione — crea un file `AGENTS.local.md` accanto al tuo `AGENTS.md`:
```markdown theme={null}
# Le mie regole personali
- Inizia sempre scrivendo test fallenti prima di implementare una soluzione
- Preferisci i patterns funzionali al codice imperativo
- Esegui l'intera suite di test prima di segnare un'attività come completata
```
Questo file viene caricato insieme a `AGENTS.md` con lo stesso comportamento sempre attivo. Aggiungilo al tuo `.gitignore` in modo che rimanga locale:
```gitignore theme={null}
AGENTS.local.md
```
Segue la stessa convenzione di `.devin/config.local.json` — il suffisso `.local.` indica un override personale che non dovrebbe essere committed.
***
## Nomi di file supportati
Devin CLI legge le regole da uno qualsiasi di questi file:
| File | Note |
| ----------------- | ------------------------------------ |
| `AGENTS.md` | Consigliato |
| `AGENTS.local.md` | Regole personali (gitignored) |
| `AGENT.md` | Alternativa al singolare |
| `.windsurfrules` | Regole del workspace Legacy Windsurf |
| `CLAUDE.md` | Compatibile con Claude Code |
Tutti questi file sono trattati allo stesso modo: il loro contenuto viene caricato come regole sempre attive.
Questi file possono trovarsi a più livelli nel tuo progetto (non solo nella directory radice). I file nella radice del workspace vengono caricati all'inizio della sessione. I file nelle sottodirectory vengono rilevati solo quando l'agente accede ai file in quella directory, mantenendo il contesto concentrato sulla parte pertinente della codebase.
Possono anche essere inseriti nella [directory di configurazione globale](#global-rules) per essere applicati a tutti i progetti, ad eccezione di `CLAUDE.md`, che viene letto globalmente da `~/.claude/CLAUDE.md`.
***
## Regole da altri strumenti
Se usi già un altro strumento di coding basato su IA, Devin CLI può leggere le regole esistenti:
Devin CLI legge `.cursor/rules/*.md` e `.cursor/rules/*.mdc`.
Le regole di Cursor supportano il frontmatter per controllarne l'attivazione:
```markdown theme={null}
---
description: "Linee guida per i componenti React"
globs: "src/components/**/*.tsx"
alwaysApply: false
---
Usa componenti funzionali con hook. Non usare mai componenti di classe.
```
**Comportamento di attivazione:**
* `alwaysApply: true` — Sempre attivo
* `globs` specificato — Attivo quando si lavora su file corrispondenti
* Solo `description` — L'agente decide quando applicarlo
* Nessuno dei precedenti — L'utente deve invocarlo manualmente
Devin CLI legge `.windsurf/rules/*.md` e `.windsurf/global_rules.md`.
**Supporto delle sottodirectory:** le directory `.windsurf/rules/` possono esistere a più livelli nel progetto, non solo nella root. Le regole nella radice del workspace vengono caricate all'inizio della sessione. Le regole nelle sottodirectory vengono individuate in modo lazy: quando l'agente accede ai file in quella directory, tutti i `.windsurf/rules/` trovati lì (e nelle directory padre fino alla radice del workspace) vengono caricati automaticamente. In questo modo si evita di appesantire il contesto dell'agente con regole provenienti da parti non correlate del progetto.
Le regole di Windsurf supportano il frontmatter:
```markdown theme={null}
---
description: "Regole di progettazione API"
trigger: always_on
---
Tutti gli endpoint API devono restituire JSON con un formato envelope coerente.
```
**Valori di trigger:** `always_on`, `manual`, `model_decision`, `agent`, `glob`
Devin CLI legge la directory `.claude/`.
Devin CLI non supporta i file `.codeiumignore`. Se usi l'autocompletamento di Codeium e hai configurato pattern di esclusione, questi pattern non verranno applicati a Devin CLI.
***
## Gestione delle importazioni
Puoi abilitare o disabilitare la lettura da specifici formati di tool nel tuo file di configurazione (`~/.config/devin/config.json` — o `%APPDATA%\devin\config.json` su Windows — o `.devin/config.json`):
```json theme={null}
{
"read_config_from": {
"agents_standard": true,
"cursor": true,
"windsurf": true,
"claude": true
}
}
```
Le regole di progetto standard contenute in `AGENTS.md`, `AGENTS.local.md`, `AGENT.md` e `.windsurfrules` vengono lette per impostazione predefinita. Imposta `"agents_standard": false` per disattivarne l'importazione.
***
## Tipi di attivazione delle regole
Le regole caricate da formati esterni possono avere comportamenti di attivazione diversi:
| Tipo | Comportamento |
| -------------------------- | ---------------------------------------------------------------------------- |
| **Sempre attive** | Attive in ogni sessione, senza richiedere alcuna azione da parte dell'utente |
| **Attivate da glob** | Attive quando l'agente lavora con file che corrispondono a pattern specifici |
| **Decise dall'agente** | L'agente sceglie quando applicarle in base alla descrizione della regola |
| **Invocabili dall'utente** | Attive solo quando vengono attivate esplicitamente dall'utente |
Le regole in `AGENTS.md` sono sempre "sempre attive".
***
## Buone pratiche
Regole lunghe e prolisse disperdono l'attenzione dell'agente. Concentrati su ciò che conta di più.
"Usa pnpm" è meglio di "usa il gestore di pacchetti giusto". Le istruzioni concrete sono più facili da seguire.
Mostra il pattern che vuoi ottenere, non limitarti a descriverlo.
Tieni le regole nella tua repo, così tutto il team può beneficiare delle stesse linee guida.
Per la maggior parte dei tipi di regole più comuni, valuta invece l'uso delle skill. Le skill ti offrono maggiore controllo su quando e come vengono applicate.