Claude Code-mallar: Skills, agenter, hooks och mer

Vad är Claude Code-mallar?

Claude Code-mallar är återanvändbara konfigurationsfiler som anpassar hur Claude Code beter sig i ett projekt eller i din lokala miljö. 

Det viktiga att förstå är att mallarna är filbaserade. Du installerar dem inte via ett vanligt inställningsgränssnitt och klickar dig igenom konfigurationsskärmar. I stället upptäcker Claude Code specifika filer och mappar, laddar relevant metadata i kontext och använder den informationen för att avgöra hur den ska agera.

I praktiken är de oftast Markdown-, JSON- eller shell-baserade filer som lagras i projektmappar såsom .claude/, eller paketeras i plugin-liknande kataloger för delning.

En typisk struktur på projektnivå kan se ut så här:

my-app/
├── CLAUDE.md
├── .mcp.json
└── .claude/
    ├── skills/
    │   └── database-migration/
    │       └── SKILL.md
    ├── agents/
    │   └── security-auditor.md
    ├── commands/
    │   └── summarize-pr.md
    └── settings.json

Claude Code-mallar vs CLAUDE.md

CLAUDE.md är fortfarande viktigt, men fyller en annan funktion. Tänk på CLAUDE.md som projektbriefen: vad projektet är, vilka kommandon som är viktiga, vilka kodningsstandarder som gäller och vilka arkitekturkonventioner Claude ska komma ihåg. 

För en djupare genomgång, se vår skrivguide för CLAUDE.md.

Mallar är mer modulära:

• En skill kan koda ett migreringsarbetsflöde. 
• En agent kan avgränsa en persona för säkerhetsgranskning. 
• En hook kan köras efter filändringar. 
• En MCP-konfiguration kan koppla Claude till GitHub, SQLite eller ett annat externt system.

Det är också här mallar hänger ihop med en bredare design av Claude Code-arbetsflöden. Välgjorda mallar fungerar bäst i kombination med goda vanor i planering, testning och kontexthantering. 

Fler sådana metoder beskrivs i vår guide till bästa praxis.

Anpassade kommandon täcks också av skills-systemet, även om det äldre formatet .claude/commands/ fortfarande fungerar. Det rekommenderade nya formatet är .claude/skills/<name>/SKILL.md, som stöder utlösning med snedstreckskommando och automatisk aktivering av Claude.

Vilka typer av Claude Code-mallar kan jag använda?

Ekosystemet för Claude Code-mallar är vanligtvis organiserat i sex kategorier: skills, agenter, kommandon, hooks, MCP-integrationer och plugins. 

De fem första ändrar Claudes beteende direkt. Plugins är lite annorlunda: de är ett distributionsformat som kan paketera skills, agenter, hooks, kommandon, MCP-servrar och andra komponenter i ett återanvändbart paket.

Vi går igenom var och en av dessa kategorier nedan.

1. Skills

Skills är instruktionspaket för upprepningsbara uppgifter i flera steg. En skill är vanligtvis en mapp som innehåller en SKILL.md-fil med YAML-frontmatter och en Markdown-kropp. 

Frontmattern beskriver vad skillen gör och hur den ska bete sig; brödtexten talar om för Claude vilka steg som ska följas. För en fördjupning, se mer i denna guide om Claude Skills.

Claude använder skillens beskrivning för att avgöra när skillen är relevant. Som standard kan både användaren och Claude anropa en skill: du kan skriva /skill-name, eller så kan Claude ladda den automatiskt när den aktuella uppgiften matchar skillens beskrivning. Du kan också inaktivera automatisk modellaktivering för arbetsflöden där du vill ha manuell kontroll, till exempel vid driftsättning.

Här är ett kort exempel på en fil: .claude/skills/database-migration/SKILL.md

---
name: database-migration
description: Use when creating, reviewing, or modifying database migrations. Ensures migrations are reversible, tested, and checked before and after execution.
allowed-tools:
  - Read
  - Write
  - Bash
---

# Database Migration Skill

When working on a database migration:

1. Inspect the existing schema and migration history before writing changes.
2. Confirm whether the migration is additive, destructive, or data-transforming.
3. Create a reversible migration whenever the framework supports rollback.
4. Run the project’s migration check command before applying the migration.
5. Run tests that cover the affected models, queries, or API endpoints.
6. After writing the migration, summarize:
   - schema changes
   - rollback behavior
   - affected tables
   - test commands run

Detta är användbart eftersom instruktionerna är procedurmässiga. Du säger inte bara åt Claude att ”vara försiktig med migreringar”. Du ger den en upprepningsbar checklista. 

Skills passar bäst för allt du annars skulle klistra in i Claude mer än två gånger: generera API-endpoints, skriva ändringsloggar, skapa teststommar, ta fram release notes, granska pull requests eller utföra migreringskontroller.

För bredare inspiration om vad utvecklare gör om till återanvändbara AI-arbetsflöden, se vår lista över Agent Skills.

2. Agenter

Agenter, mer precist anpassade subagenter i Claude Code, är specialiserade AI-assistenter med egna Markdown-definitioner, YAML-frontmatter, verktygsbegränsningar, modellval och systemprompt. 

De kan ligga i .claude/agents/ för projektnivå eller ~/.claude/agents/ för personlig nivå. Agenter skapas genom att be Claude eller genom att redigera markdownfiler direkt i mappen .claude/agents/.

Det finns faktiskt en skillnad mellan skills och agenter. En skill definierar hur en uppgift ska utföras. En agent definierar vem Claude ska vara när arbetet utförs: dess roll, fokus, behörigheter och gränser.

Låt oss titta på detta exempel på en agent:

---
name: security-auditor
description: Reviews code for security vulnerabilities and produces a findings report without modifying files.
tools: Read, Glob, Grep, Bash
model: sonnet
---

You are a security auditor.

Your task is to inspect the codebase for vulnerabilities, risky patterns, and missing safeguards.

Rules:
- Do not edit files.
- Do not suggest broad rewrites unless directly tied to a security issue.
- Focus on authentication, authorization, input validation, secrets, dependency risk, and unsafe shell or SQL usage.
- Produce a findings report with severity, affected files, evidence, and recommended next steps.

Den här agenten är hjälpsam eftersom den ger Claude tydliga gränser. I en allmän session kan Claude börja åtgärda problem så fort den hittar dem. En säkerhetsgranskningsagent instrueras att endast inspektera och rapportera, och undvika ändringar. 

Agenter passar bäst för specialiserade områden som säkerhetsgranskning, dokumentationsgranskning, arkitekturgranskning, data engineering eller kodkvalitetskontroller, där kontextisolering och behörighetsgränser är viktiga.

Agenter är också användbara i kombination med specialiserade skills. Till exempel kan en säkerhetsgranskningsagent anropa en skill för granskningsrapport, medan en frontendgranskare kan använda en skill för komponenttestning.

3. Kommandon

Kommandon är snedstrecksutlösta genvägar som /generate-tests, /check-deps eller /summarize-pr. Historiskt lagrades anpassade kommandon som Markdown-filer under .claude/commands/, där filnamnet fungerade som kommandonamn. 

Claude Code stöder fortfarande detta äldre format, men jag rekommenderar att använda skills för nya kommando-liknande arbetsflöden, eftersom de stöder samma /name-utlösning och automatisk aktivering när det är lämpligt.

Kommandon är bäst när du vill att utlösaren ska vara explicit. En skill kan aktiveras automatiskt när Claude upptäcker en matchande uppgift, men ett kommando ska bara köras när du själv väljer det. Det gör kommandon användbara som kontrollpunkter: ”generera tester nu”, ”sammanfatta den här PR:en nu”, ”kontrollera beroenden nu” eller ”förbered ett commit-meddelande nu”.

4. Hooks

Hooks är automationsregler som körs som svar på livscykelhändelser i Claude Code. De är användardefinierade shell-kommandon som exekveras vid specifika punkter i Claude Codes livscykel, vilket ger deterministisk kontroll över beteendet. 

Skillnaden mellan hooks och de andra mallarna vi hittills täckt är att de inte triggas av vad du ber om, utan av vad Claude gör.

Enkelt uttryckt behöver du inte hoppas att Claude kommer ihåg att formatera en fil efter att ha redigerat den; en hook kan göra det automatiskt.

Nuvarande hook-händelsenamn inkluderar sådana som PreToolUse, PostToolUse, Notification och Stop. 

Exempel: kör en formatterare efter att Claude redigerar eller skriver en fil:

{
  "hooks": {
    "PostToolUse": [
      {
        "matcher": "Edit|Write",
        "hooks": [
          {
            "type": "command",
            "command": "jq -r '.tool_input.file_path' | xargs npx prettier --write"
          }
        ]
      }
    ]
  }
}

Example: block risky shell commands before Claude runs them:
{
  "hooks": {
    "PreToolUse": [
      {
        "matcher": "Bash",
        "hooks": [
          {
            "type": "command",
            "command": "python3 .claude/hooks/block-dangerous-bash.py"
          }
        ]
      }
    ]
  }
}

Hooks passar bäst för regler som Claude inte ska kunna hoppa över: köra en linter, formatera redigerade filer, blockera skyddade filändringar, kontrollera genererad kod eller skicka aviseringar när Claude behöver input. 

För en djupgående handledning, läs vår guide till Claude Code Hooks.

5. MCP-integrationer

MCP-integrationer kopplar Claude Code till externa verktyg, datakällor och API:er via Model Context Protocol. MCP fungerar som ett kopplingslager mellan AI-system och externa verktyg. I Claude Code innebär detta att Claude kan gå bortom lokala filer och shell-kommandon. 

Det låter Claude interagera med externa tjänster som GitHub, databaser, dokumentationssystem, molnplattformar eller interna API:er, beroende på vilka MCP-servrar du konfigurerar. För en komplett förklaring och ett demoprojekt, se vår handledning om Model Context Protocol.

En MCP-server kan exponera tre breda typer av kapacitet:

• Verktyg: körbara funktioner som Claude kan anropa, såsom att skapa ett GitHub-ärende eller köra en databasfråga.
• Resurser: skrivskyddade kontextkällor, såsom en fil, en databastabellrad eller ett dokument.
• Prompter: återanvändbara uppgiftsmallar som servern exponerar.

En .mcp.json på projektnivå kan konfigurera flera servrar sida vid sida:

{
  "mcpServers": {
    "github": {
      "type": "stdio",
      "command": "npx",
      "args": ["-y", "@modelcontextprotocol/server-github"],
      "env": {
        "GITHUB_PERSONAL_ACCESS_TOKEN": "${GITHUB_TOKEN}"
      }
    },
    "sqlite": {
      "type": "stdio",
      "command": "npx",
      "args": [
        "-y",
        "@modelcontextprotocol/server-sqlite",
        "./data/app.db"
      ]
    }
  }
}

Detta spelar roll eftersom Claude bara kan resonera utifrån den kontext och de verktyg den har tillgång till. Utan MCP kan den inspektera lokala filer men inte din ärendehanterare, databas, molnmiljö eller interna API. 

En MCP är bäst när Claude behöver arbeta med den verkliga stacken snarare än en statisk kod-ögonblicksbild och när den behöver tillgång till extern data.

6. Plugins

Plugins är paketerade buntar. De kan inkludera skills, agenter, hooks, MCP-konfigurationer, kommandon och andra komponenter inom en enda installerbar struktur. 

I Claude Code inkluderar ett plugin typiskt ett manifest .claude-plugin/plugin.json och komponentmappar som skills/, agents/, hooks/ och .mcp.json i pluginets rot.

Exempel på plugin-struktur:

frontend-workflow-plugin/
├── .claude-plugin/
│   └── plugin.json
├── skills/
│   └── component-test/
│       └── SKILL.md
├── agents/
│   └── frontend-reviewer.md
├── hooks/
│   └── hooks.json
└── .mcp.json

Exempel på ett plugin-json:

{
  "name": "frontend-workflow",
  "displayName": "Frontend Workflow",
  "version": "1.0.0",
  "description": "Frontendutvecklingsflöde med granskningsagenter, test-skills och formateringshooks",
  "author": {
    "name": "Your Team"
  }
}

Plugins lägger inte till en ny beteendetyp. De gör de andra typerna portabla. Använd plugins när du vill dela en komplett uppsättning över ett team, återanvända samma arbetsflöde över projekt eller installera en community-underhållen bunt i stället för att skapa varje fil manuellt.

För att bygga ett från grunden, se DataCamps steg-för-steg-guide för Claude Code-plugins.

Vilken malltyp ska jag välja?

Jag förstår helt; alla dessa typer kan vara förvirrande. De kan alla ändra hur Claude beter sig. Skillnaden handlar mest om hur de triggas och vilken typ av kontroll de ger.

För att göra det tydligare, här är en jämförelse mellan dem:

En enkel beslutsregel hjälper:

• Om du vill automatiskt upprätthålla en regel varje gång Claude rör kod, använd en hook. 
• Om du vill att Claude ska anta djup domänexpertis för en specifik uppgift, använd en agent. 
• Om du vill koda ett arbetsflöde som Claude ska upprepa konsekvent, använd en skill. 
• Om du vill själv utlösa en åtgärd vid rätt tillfälle, använd ett kommando eller en kommando-liknande skill. 
• Om Claude behöver externa tjänster eller live-data, använd MCP. 
• Om du vill installera eller dela en komplett arbetsflödes-setup, använd ett plugin.

I verkliga projekt kombineras dessa typer oftast. Ett säkerhetsplugin kan paketera en security-auditor-agent, en audit-findings-skill, ett beroendekommando och en pre-commit-hook. Agenten definierar rollen, skillen definierar rapportstrukturen, kommandot ger dig en explicit kontrollpunkt och hooken upprätthåller skyddsräcket.

För arbetsflöden där Claude ska följa en formell plan före implementering är specdriven utveckling ofta ett bättre val än ad hoc-promptning.

Var kan jag hitta Claude Code-mallar?

Det finns tre praktiska källor: Anthropic, community-samlingar och du själv.

Börja först med officiella Anthropic-resurser och dokumentation. Anthropics Claude Code-dokumentation täcker skills, subagenter, hooks, MCP och plugins, och är den bästa platsen för att verifiera aktuella filformat och beteenden innan du publicerar något i produktion.

För det andra, använd community-samlingar. Den mest synliga hubben är aitmpl.com, som beskriver sig som en katalog med färdiga konfigurationer för Claude Code-projekt. Dess aktuella navigation inkluderar Skills, Agents, Commands, Settings, Hooks, MCPs och Plugins. 

Det nuvarande interaktiva installationskommandot är:

npx claude-code-templates@latest

Projektets dokumentation visar också ett kortare alias:

npx cct@latest

För specifika komponenter visar den aktiva README:n på GitHub installationskommandon som:

npx claude-code-templates@latest --agent development-tools/code-reviewer --yes
npx claude-code-templates@latest --command performance/optimize-bundle --yes
npx claude-code-templates@latest --hook git/pre-commit-validation --yes
npx claude-code-templates@latest --mcp database/postgresql-integration --yes

Den visar också batchinstallation av en full stack med flera flaggor i ett enda kommando.

När du utvärderar community-mallar, kontrollera några kvalitetssignaler:

• Är description tillräckligt specifik för att Claude ska trigga skillen eller agenten korrekt?

• Är allowed-tools snävt avgränsade, eller begär mallen onödigt breda skriv- och bash-behörigheter?

• Har förvaret underhållits nyligen?

• Förklarar mallen vad den ändrar?

• Inkluderar den hooks eller MCP-servrar som kör kod du inte har granskat?

För det tredje, skriv egna. Detta är oftast det rätta svaret för arbetsflöden som är tätt kopplade till din stack. En community-mall kan ge dig en bra bas, men den kan inte känna till din interna migreringspolicy, namngivningskonventioner, datamodell eller tolerans för driftsättningsrisk.

Avslutande tankar

Claude Code-mallar är hur Claude Code går från en assistent från session till session till en beständig utvecklingsmiljö. 

De sex kategorierna jag nämnt är egentligen lager: skills kodar arbetsflöden, agenter definierar roller, kommandon skapar explicita åtgärder, hooks upprätthåller skyddsräcken, MCP kopplar externa system och plugins paketerar allt för återanvändning.

Den bästa starten är inte en stor plugin-stack. Jag skulle börja med en enda skill för ditt mest upprepade arbetsflöde. När du ser var Claudes standardbeteende fortfarande skapar friktion, lägg till en agent för specialiserad granskning, en hook för efterlevnad eller en MCP-server för tillgång till live-system.

För mer lärande om Claude Code, kolla in våra kurser Claude Code 101 och Claude Code in Action.