Your development
teammates in one plugin

for Claude Code and OpenCode (in development)

19 specialised agents with their own personality. 10 core, 9 optional. Up to 7 phases, 26 commands, persistent memory and automatic quality gates at every transition.

Now on main
Lucius — external technical second opinion New When Alfred is done, Lucius calls Codex CLI for an outside perspective. Diagnosis and prescription per item: security, architecture, tests or performance. Touches nothing. You decide what to implement and with whom.
Selina — visual style direction New Before a single line of CSS is written, Selina presents three style proposals in the browser. The user chooses; the team executes with coherence from the first component.
Real operational continuity Alfred can now tell you what to do next, pause a session, resume it, and show project state without forcing you to reread half the repo.
Brownfield without flying blind Existing repos now start with map-codebase and discuss: Alfred leaves a persistent codebase map before opening implementation workflows.
Quick mode with guardrails Small changes now have a dedicated lightweight workflow: less ceremony than feature, but still with tests, local regression checks and security review.
Explicit UAT and traceability verify separates automatic tests from human acceptance, while progress exposes kanban, blockers, traceability and UAT state.
SonIA usable from CLI standup, blocked, in-progress, validate and search turn the local kanban into a daily operational interface instead of hidden documentation.
GitHub as an optional mirror SonIA Sync publishes backlog, blockers and progress to GitHub Issues with gh, without giving up local truth in docs/project and SQLite.
Browser-based Memory UI The project SQLite memory can now open as a live local UI: overview, timeline, decisions, commits, search, health and operational signals.
19
Agents
60
Skills
6
Workflows
26
Commands
7
Templates
13
Hooks
23
Gates
The team

10 core agents

Each agent has a defined role, its own personality and signature phrases. They work coordinated by Alfred, the head butler. Always active in every workflow.

Alfred opus
Head butler
Team orchestrator. Decides which agents to activate, in what order, and evaluates the quality gates between phases.
"Very well, sir. Allow me to organise that."
SonIA sonnet
Project Manager
If it's not on the kanban, it doesn't exist. Breaks down the PRD into tasks, traces every acceptance criterion to its test and documentation, and detects scope drift.
"Criterion AC-05 has no associated test. Who's on it?"
The Problem Finder opus
Product Owner
Obsessed with the user's problem. PRDs, user stories, acceptance criteria, competitive analysis.
"Very nice, but what problem does this solve?"
The Box Drawer opus
Architect
Thinks in systems, not lines of code. Mermaid diagrams, ADRs, decision matrices, dependency evaluation.
"If it doesn't fit in a diagram, it's too complex."
The Craftsman opus
Senior Dev
Pragmatic, test-first. Strict TDD, refactoring, atomic commits. Chronic allergy to clever code.
"Test first. Always test first."
The Paranoid opus
Security Officer
Distrustful by default. OWASP Top 10, GDPR/NIS2/CRA compliance, dependency auditing, threat modelling, SBOM.
"Did you validate that input? No, seriously."
The Breaker sonnet
QA Engineer
His mission is to prove the code doesn't work. Test plans, code review, exploratory testing, regression.
"That edge case you didn't consider? Found it."
The Plumber sonnet
DevOps Engineer
Invisible infrastructure is well-done infrastructure. Docker, CI/CD, deploy, monitoring. All automated.
"If you deploy it manually, you're deploying it wrong."
The Scribe sonnet
Tech Writer
Document first. Writes inline code docs (headers, docstrings) and generates project documentation: API docs, architecture with Mermaid diagrams, guides and changelogs.
"That file has no header. Nobody knows what it's for."
Selina opus
The Stylist
Visual style director. Ensures typography, palette and visual density are decided before the architect designs the first component. Only active in projects with a user interface.
"Style is not decoration: it's communication."
Extensible

9 optional agents

Specialised roles you activate according to your project's needs. Alfred analyses your stack and suggests which to enable. Managed with /alfred-dev:config.

The Data Plumber sonnet
Data Engineer
Schema design, migrations with mandatory rollback, query optimisation. If there's a database, there's work.
"A migration without rollback is a one-way ticket."
The User Advocate sonnet
UX Reviewer
WCAG 2.1 AA audit, Nielsen heuristics, flow review. What's obvious to you isn't obvious to the user.
"If the user needs a manual, you've failed."
The Stopwatch sonnet
Performance Engineer
Profiling, benchmarks with real statistics (p50, p95, p99), bundle analysis. Measure before and after, always.
"Without numbers there's no optimisation, just superstition."
The Gatekeeper sonnet
GitHub Manager
Repository configuration, branch protection, PRs, releases, issue templates. All via gh CLI, no AI mentions.
"A repo without branch protection is Russian roulette."
The Tracker sonnet
SEO Specialist
Meta tags, JSON-LD structured data, Core Web Vitals, Lighthouse. If Google can't find it, it doesn't exist.
"A wrong canonical and you've got duplicate content."
The Quill sonnet
Copywriter
Text review, effective CTAs, tone guide. Impeccable spelling as absolute priority. No infomercials.
"If you write 'aplication' without the double p, don't publish."
The Librarian sonnet
Project memory
Answers historical queries about project decisions, commits and iterations. Always cites sources with verifiable IDs: [D#id], [C#sha], [I#id].
"According to decision D#42 from February 15th, Redis was discarded due to latency."
The Interpreter sonnet
i18n Specialist
i18n key audit, hardcoded string detection, per-locale format validation. If the base language has N keys, all others must have N.
"The base language has 847 keys. French has 831. 16 missing."
Lucius opus
External technical director
External technical second opinion via Codex CLI with GPT-5.4. Audits the full project and returns diagnosis and prescription per item. Requires an active OpenAI subscription. No modifications: analysis only.
"From the outside, this has a weak point you probably can't see because you're too close to it."
Dynamic composition

The team you need, when you need it

When Alfred detects that it is time to open a multi-agent workflow, it analyzes your task in real time and suggests the most relevant optional agents. If mapping, resuming, verifying or showing progress comes first, it resolves that before composing a full team.

When /alfred-dev:alfred or an explicit command decides that the correct route is a multi-agent workflow, Alfred reasons about which specialists fit the work, presents the selection and starts the right phase. This is what it looks like when the chosen route is /alfred-dev:feature:

terminal
$ /alfred-dev:feature
|
Workflows

6 execution workflows, 18 phases

Each workflow runs phase by phase. Between phases there is a quality gate (the section below lists all of them). Outside the workflows, commands like next, pause, resume and progress let you pause, pick up or check status without losing the thread.

/alfred-dev:feature
Full or partial cycle
Up to 7 phases: product, visual style (Selina, conditional), architecture, TDD development, quality + security, documentation, delivery. You can start from any phase.
1Product 2Visual style 3Architecture 4Development 5Quality + Security 6Documentation 7Delivery
/alfred-dev:quick
Small change
2 phases: bounded execution and quick validation. Less ceremony than feature, but still with tests and security review.
1Bounded execution 2Quick validation
/alfred-dev:fix
Quick fix
Root cause diagnosis, TDD fix (test that reproduces the bug first), QA + security validation.
1Diagnosis 2TDD Fix 3Validation
/alfred-dev:spike
Investigation
Technical exploration with no commitment: prototypes, benchmarks, evaluation of alternatives. Findings document.
1Investigation 2Findings
/alfred-dev:ship
Deployment
Parallel final audit, release documentation, packaging with semantic versioning, production deployment.
1Audit 2Documentation 3Packaging 4Deployment
/alfred-dev:audit
Audit
4 agents working in parallel: quality, security, architecture and documentation. Consolidated report with priorities.
1Parallel audit
Quality gates

Quality coverage across the entire cycle

Each development phase has its own quality gates. The 10 core agents cover from product validation to delivery, and the optional agents extend control to specialised domains. If a gate fails, the workflow stops.

Core -- from idea to production

Validates the PRD with the user before moving to design
Reviews architectural coherence and module coupling before coding
Analyses the design for attack vectors using threat modelling
Applies strict TDD: failing test, minimal implementation, refactor
Runs unit, integration and E2E tests before advancing to quality
Audits OWASP Top 10, dependency CVEs and GDPR, NIS2, CRA compliance
Documents code inline during development and generates project docs at closure
Requires a green CI/CD pipeline as a delivery prerequisite
Tracks progress between phases and maintains full decision traceability
Queries the project's persistent memory to contextualise with historical data
Monitors every file write looking for secrets, API keys or tokens
Detects missing accents in Spanish when writing or editing files
Verifies that tests were actually executed before accepting they pass (verifiable evidence)
Iterates within each phase up to 5 times if the gate fails, enabling natural TDD cycles

Optional -- extend the coverage

Analyses code with SonarQube (installs Docker if missing, with your permission)
Requires rollback in every database migration before executing it
Verifies WCAG 2.1 AA accessibility before approving the interface
Measures performance with real metrics (p50, p95, p99) before and after
Configures branch protection on main and requires PR with approval
Monitors Core Web Vitals (LCP, INP, CLS) and alerts if out of threshold
Reviews meta tags, structured data and SEO crawlability before publishing
Validates spelling, tone and consistency of interface texts
Checks that all i18n keys from the base language exist in every target language
Capabilities

60 skills across 13 domains

Each skill is a specific ability that agents execute. The original 7 domains are expanded with 6 new ones for the optional agents.

Product 4 skills
  • write-prd Complete PRD with stories and criteria
  • user-stories User story decomposition
  • acceptance-criteria Given/When/Then criteria
  • competitive-analysis Alternatives analysis
Architecture 4 skills
  • write-adr Architecture Decision Records
  • choose-stack Stack decision matrix
  • design-system Design with Mermaid diagrams
  • evaluate-dependencies Dependency audit
Development 4 skills
  • tdd-cycle Red-green-refactor cycle
  • explore-codebase Code exploration
  • refactor Guided refactoring
  • code-review-response Code review response
Security 6 skills
  • threat-model STRIDE modelling
  • dependency-audit CVEs, licences, versions
  • security-review OWASP Top 10
  • compliance-check GDPR, NIS2, CRA
  • sbom-generate Software Bill of Materials
  • dependency-update Secure dependency updates
Quality 6 skills
  • test-plan Risk-based test plans
  • code-review Quality review
  • exploratory-test Exploratory testing
  • regression-check Regression analysis
  • sonarqube SonarQube + Docker analysis
  • spelling-check Spelling verification (accents)
DevOps 4 skills
  • dockerize Multi-stage Dockerfile
  • ci-cd-pipeline GitHub Actions, GitLab CI
  • deploy-config Vercel, Railway, Fly, AWS, K8s
  • monitoring-setup Logging, alerts, tracking
Documentation 9 skills
  • api-docs Endpoints, params, examples
  • architecture-docs System overview
  • user-guide Installation, usage, troubleshooting
  • changelog Keep a Changelog
  • project-docs Full documentation in docs/
  • glossary Project linguistic corpus
  • readme-review README audit
  • onboarding-guide New developer guide
  • migration-guide Version migration
Data 3 skills
  • schema-design Normalised schema design
  • migration-plan Migrations with rollback
  • query-optimization Optimisation with EXPLAIN
UX 3 skills
  • accessibility-audit Full WCAG 2.1 AA
  • usability-heuristics Nielsen's 10 heuristics
  • flow-review User flow analysis
Performance 3 skills
  • profiling CPU and memory per runtime
  • benchmark Benchmarks with p50, p95, p99
  • bundle-size Bundle analysis and reduction
GitHub 4 skills
  • repo-setup Full repo configuration
  • pr-workflow Well-documented PRs
  • release Releases with semantic versioning
  • issue-templates YAML issue templates
SEO 3 skills
  • meta-tags Title, description, Open Graph
  • structured-data JSON-LD for schema.org
  • lighthouse-audit Core Web Vitals and metrics
Marketing 3 skills
  • copy-review Public text review
  • cta-writing Effective CTAs without infomercials
  • tone-guide Brand tone guide
Under the hood

Hooks, templates and core

The infrastructure that powers the team: hooks that bootstrap sessions, templates that standardise artifacts, and a core that orchestrates both execution workflows and operational continuity.

13 hooks

session-bootstrap.sh SessionStart
session-start.sh SessionStart
stop-hook.py Stop
secret-guard.sh PreToolUse
dangerous-command-guard.py PreToolUse
sensitive-read-guard.py PreToolUse
prefetch-finish-guard.py PreToolUse
quality-gate.py PostToolUse
evidence-guard.py PostToolUse
dependency-watch.py PostToolUse
spelling-guard.py PostToolUse
activity-capture.py PostToolUse
memory-compact.py PreCompact

7 templates

prd.md Product Requirements
adr.md Architecture Decision
test-plan.md Test plan
threat-model.md STRIDE modelling
sbom.md Bill of Materials
changelog-entry.md Changelog entry
release-notes.md Release notes

6 core modules

orchestrator.py Workflows, sessions, gates, iterative loop and autopilot
continuity.py Continuity, operational PM, search and GitHub sync
personality.py Personality engine
config_loader.py Config and stack detection
memory.py SQLite persistent memory
session_report.py Markdown session reports
Interface

26 commands

Everything is controlled from the Claude Code command line.

Workflows
/alfred-dev:feature Full cycle: up to 7 phases or from any phase you name. Selina activates automatically in UI projects.
/alfred-dev:quick Small bounded change with two lightweight phases: scoped execution and fast QA + security validation.
/alfred-dev:fix Bug fix in 3 phases: diagnosis, TDD correction, validation.
/alfred-dev:spike Exploratory investigation with no commitment: prototypes, benchmarks, conclusions.
/alfred-dev:ship Prepare release: final audit, documentation, packaging, deployment.
/alfred-dev:audit Full audit with 4 agents in parallel: quality, security, architecture, documentation.
Context
/alfred-dev:alfred Contextual assistant: reads project state and decides whether to map, resume, refine or open a workflow.
/alfred-dev:map-codebase Analyzes an existing repo and creates codebase-map.md and current.md before touching code.
/alfred-dev:discuss Refines an idea before implementation. Leaves discovery.md and a recommended next command.
/alfred-dev:lucius External second opinion via Codex CLI (GPT-5.4). Diagnosis and prescription per item. Requires OpenAI subscription.
Continuity
/alfred-dev:next Answers “what now” and acts if the route is unambiguous: resume, verify, map or suggest the next workflow.
/alfred-dev:pause Pauses work and leaves an explicit handoff in .claude/alfred-handoff.json.
/alfred-dev:resume Resumes an active session or pending handoff without blindly opening a new iteration.
/alfred-dev:verify Records manual UAT for the current deliverable, separating human acceptance from automated tests.
Operational PM
/alfred-dev:progress Progress, kanban, blockers, traceability and UAT state in one compact view.
/alfred-dev:standup Actionable daily standup: current focus, in-flight work, blockers and recommended next step.
/alfred-dev:blocked Blocked tasks with dependency, operational note and owner.
/alfred-dev:in-progress In-flight work without rereading the whole board.
/alfred-dev:validate Board health: duplicate IDs, incomplete traceability, pending UAT, sync drift.
/alfred-dev:search Searches artifacts and SQLite memory together to answer historical or operational questions.
/alfred-dev:sync-github SonIA Sync: mirrors the local board into GitHub Issues via gh.
Tools
/alfred-dev:memory-ui Local browser UI over the project SQLite: overview, timeline, decisions, commits, search.
/alfred-dev:config Autonomy, stack, compliance, personality, optional agents and memory. Bootstrappable on first session.
/alfred-dev:status Active session: current phase, completed phases, pending gate and immediate focus.
/alfred-dev:update Check for a new version, read release notes and update with one click.
/alfred-dev:help Full help for all available commands.
The 9 optional agents are activated with /alfred-dev:config and Alfred integrates them automatically in feature, quick, fix, spike, audit and ship.
Automatic detection

Adapts to your project

Alfred Dev automatically detects your project's technology stack and adapts its artefacts to the actual ecosystem.

Node.js -- npm, pnpm, bun, yarn. Express, Next.js, Fastify, Hono.
Python -- pip, poetry, uv. Django, Flask, FastAPI.
Rust -- cargo. Actix, Axum, Rocket.
Go -- go mod. Gin, Echo, Fiber.
Ruby -- bundler. Rails, Sinatra.
Elixir -- mix. Phoenix.
Java / Kotlin -- Maven, Gradle. Spring Boot, Quarkus, Micronaut.
PHP -- Composer. Laravel, Symfony.
C# / .NET -- dotnet, NuGet. ASP.NET, Blazor.
Swift -- SPM. Vapor.
In practice

How it's used

Real usage scenarios step by step. Each case shows the full flow from invocation to result.

Development
Develop a complete feature
/alfred-dev:feature push notification system
  • The product-owner generates the PRD with user stories and acceptance criteria
  • The architect designs the solution and the security-officer validates the design
  • The senior-dev implements following strict TDD (red-green-refactor)
  • QA and security audit in parallel before giving the green light
  • The Scribe documents inline code and generates API docs; the devops-engineer prepares deployment
Bug fix
Fix a bug
/alfred-dev:fix login fails with emails containing accents
  • The senior-dev reproduces the error and identifies the root cause
  • Writes a test that fails reproducing the exact bug
  • Implements the minimal fix that makes the test pass
  • QA and security validate that no regressions were introduced
Investigation
Technical investigation (spike)
/alfred-dev:spike evaluate migrating from REST to gRPC
  • The architect and senior-dev explore alternatives with no code commitment
  • Lightweight proofs of concept are generated to compare performance
  • An ADR is documented with findings, pros, cons and recommendation
  • The user decides whether to proceed with implementation or discard it
Audit
Audit the project
/alfred-dev:audit
  • 4 agents work in parallel: QA, security, architecture and documentation
  • QA looks for logic errors, code smells and test coverage
  • Security analyses OWASP Top 10, dependencies with CVEs and GDPR/NIS2 compliance
  • A single report is consolidated with findings prioritised by severity
Delivery
Prepare a release
/alfred-dev:ship
  • Mandatory final audit: QA and security must approve
  • The Scribe updates the changelog and generates release notes
  • The devops-engineer packages, configures the pipeline and verifies the build
  • Supervised deployment: the user confirms before pushing to production
Conversational
Contextual assistant
/alfred-dev:alfred
  • Alfred detects the project stack, active session, pending handoff and whether brownfield mapping is missing
  • It decides whether the right route is next, map-codebase, discuss, quick, feature, fix, spike, audit, verify or progress
  • If the correct route is operational, it resolves that before opening a multi-agent team
  • It only composes agents when it is actually time for an execution workflow
Brownfield
Enter an existing repository
/alfred-dev:map-codebase checkout
  • Alfred analyzes README, manifests, main structure and sensitive areas without touching product code
  • It generates docs/project/codebase-map.md with domains, entrypoints, hotspots, tests, deployment and risks
  • It leaves docs/project/current.md with an operational reading and the recommended next command
  • From that point on, feature, fix, spike and audit no longer start blind
Refinement
Clarify an idea before building
/alfred-dev:discuss new onboarding for teams
  • Alfred clarifies the real problem, main actor, scope and assumptions before talking implementation
  • It persists the refinement in docs/project/discovery.md and updates docs/project/current.md
  • If the idea is mature enough, it recommends feature or quick; if technical data is still missing, spike
  • It avoids opening PRD, architecture or development too early
Small change
Resolve something small without opening the whole machine
/alfred-dev:quick fix checkout copy and its test
  • Quick opens a lightweight session with two phases: bounded execution and quick validation
  • The senior-dev changes only the touched surface and updates the necessary tests
  • QA and security review local regression and obvious risks without turning it into a global audit
  • The expected next step stays explicit: /alfred-dev:verify
Continuity
Know what comes next
/alfred-dev:next
  • It prioritises active session, pending handoff, pending UAT or an unmapped brownfield repo
  • If the outcome is unambiguous, it executes the correct route without showing a generic menu
  • If there is work to resume, it shows the workflow, current phase, pending gate and exact next action
  • If nothing is active, it suggests the most reasonable workflow for the current project state
Continuity
Pause and resume without losing the thread
/alfred-dev:pause
  • Pause writes the handoff to .claude/alfred-handoff.json and docs/project/handoff.md
  • Resume reuses state and handoff to return exactly to the point where work stopped
  • It does not open a new iteration or push gates by itself: it first makes the next step explicit
  • It works equally well for long feature sessions and interrupted quick work
Verification
Close manual acceptance
/alfred-dev:verify approved manual smoke looked good
  • Verify prepares or updates UAT for the current deliverable in .claude/alfred-uat.json and docs/project/uat.md
  • It clearly separates automatic tests from final human validation
  • It records whether UAT is pending, approved or rejected, together with the main note
  • If validation fails, the next operational step becomes visible again in current/uat artifacts
Project management
See the project's real state
/alfred-dev:progress
  • Progress exposes SonIA's operational layer: general progress, kanban, blockers and traceability
  • It summarises the active workflow or pending handoff without reopening the current work
  • It shows traceability gaps and UAT state if they exist
  • It closes with the recommended next command to keep moving
Project management
Get a daily standup without opening GitHub or rereading docs
/alfred-dev:standup
  • Standup summarises current focus, in-flight tasks, blockers, recent evidence and the operational recommendation
  • It reads SonIA's kanban, continuity state and any pending or approved UAT
  • It works as a quick briefing before you keep working or delegate a task
  • It does not modify the board: it only makes the important state visible
Project management
Validate board health before moving on
/alfred-dev:validate
  • Validate reviews backlog, in-progress, blocked and done looking for duplicate IDs or tasks missing basic metadata
  • It cross-checks traceability, evidence, UAT and key artifacts such as progress.md or traceability.md
  • If local GitHub sync exists, it also detects drift between tasks and issues
  • It returns an actionable checklist so the board is corrected before more work happens
Project management
Run SonIA Sync with GitHub
/alfred-dev:sync-github owner/repo
  • Reads the local board and creates or updates issues for backlog, in-flight work, blockers and completed tasks
  • Ensures Alfred labels and a SonIA Sync umbrella issue with the overall summary
  • Stores the local mapping in .claude/alfred-github-sync.json and a human summary in docs/project/github-sync.md
  • GitHub acts as a collaboration mirror: truth stays in docs/project and SQLite
Context
Search context without exploring half the repo
/alfred-dev:search social login
  • Search crosses discovery, current, handoff, UAT, kanban and persistent memory in a single query
  • It returns operational artifacts and historical decisions together, with visible origin
  • It is especially useful to answer why a decision was made or where a blocker was written down
  • It avoids manually opening multiple Markdown files or querying SQLite separately
Memory
Open the project's live memory
/alfred-dev:memory-ui
  • Launches a local browser UI on top of the project's real SQLite memory without duplicating the source of truth
  • Shows overview, timeline, decisions, commits, search and storage health in one place
  • Blends persistent memory with operational signals from current, progress, traceability and kanban when available
  • Auto-refreshes while Alfred keeps working, so it can act as a live dashboard for the project
Visual style
Decide the visual style before building
/alfred-dev:feature new personal finance app
  • Selina reads the approved PRD, detects the stack (framework, components, product context) and confirms the target audience
  • Launches the local visual server and generates three full-screen HTML proposals: each with a different typeface, palette, density and personality
  • The user chooses in the browser; Selina records the choice and generates docs/style-direction.md with the full direction
  • Architect, senior-dev, ux-reviewer, copywriter and seo-specialist read that artefact as the style reference for the rest of the workflow
  • The phase is skipped automatically in projects without a user interface
Quality
SonarQube analysis
/alfred-dev:audit
  • The security-officer checks if Docker is installed; if not, asks the user for permission to install it
  • Spins up SonarQube with Docker automatically and waits until it's ready
  • Configures the project, runs the scanner and waits for results
  • Translates findings (bugs, vulnerabilities, code smells) into a report with proposed fixes
  • Cleans up the container when done: leaves nothing running
Data
Design and migrate a database
/alfred-dev:feature add subscription system with payments
  • The data-engineer designs the normalised schema with constraints and indices
  • Generates the migration script with mandatory rollback (forward and back)
  • The architect validates integration with the ORM and the rest of the stack
  • The migration is executed, tables are verified and integration tests are run
GitHub
Configure and publish a repository
/alfred-dev:ship
  • The github-manager verifies that gh CLI is installed and authenticated; if not, guides the process
  • Configures branch protection, labels, issue templates and optimised .gitignore
  • Creates the PR with structured description, labels and reviewer assignment
  • Generates the release with semantic versioning, categorised changelog and attached artefacts
SEO + Copy
Optimise a landing page
/alfred-dev:audit
  • The seo-specialist audits meta tags, Open Graph, canonical and JSON-LD structured data
  • Runs Lighthouse and prioritises improvements by Core Web Vitals impact
  • The copywriter reviews texts: spelling (accents first), clarity, tone and CTAs
  • A joint report is generated with fixes ready to apply
UX
Accessibility and usability audit
/alfred-dev:audit
  • The ux-reviewer runs a WCAG 2.1 AA audit across the 4 principles (perceivable, operable, understandable, robust)
  • Applies Nielsen's 10 heuristics to the user's main flow
  • Identifies friction points, edge cases and unnecessary steps in each flow
  • Generates a report with severity (0-4) and improvement proposal for each finding
Performance
Optimise performance
/alfred-dev:spike the API takes 3 seconds to respond
  • The performance-engineer runs CPU and memory profiling to locate bottlenecks
  • Analyses slow queries with EXPLAIN and proposes indices or restructuring
  • Runs benchmarks before and after with real metrics (p50, p95, p99)
  • If there's a frontend, analyses bundle size and proposes tree-shaking or code splitting
Automatic
Background protection

Without running any command, Alfred automatically monitors your work session through hooks that trigger on every relevant operation.

  • Secret guard -- blocks writing API keys, tokens or passwords in code
  • Quality gate -- verifies tests pass after every significant change
  • Evidence verification -- records every test execution as verifiable evidence, preventing claims without proof
  • Dependency watch -- detects new libraries and notifies the security auditor
  • Spelling guard -- detects Spanish words missing accents when writing or editing files
  • Memory capture -- automatically records workflow events in persistent memory
  • Commit capture -- detects every git commit and records SHA, author and files in memory
  • Protected context -- critical decisions survive context compaction
  • Session report -- when a completed session closes, a summary is generated in docs/alfred-reports/ with phases, evidence and artefacts
Autonomy
Autopilot mode
/alfred-dev:feature --autopilot
  • The full workflow runs unattended: user gates are approved automatically
  • Automatic gates (tests) and security gates are still evaluated normally
  • If an automatic gate fails, the iterative loop retries up to 5 times before escalating
Persistent memory per project

Persistent memory

Alfred Dev remembers decisions, commits and iterations between sessions. Memory is stored in a local SQLite database inside each project, with no external dependencies or remote services. Since v0.2.3: tags, status and relationships between decisions, auto-capture of commits, advanced filters and export/import.

Local database

SQLite with WAL mode for concurrent writes. Stores decisions, commits, iterations and events in .claude/alfred-memory.db inside each project. 0600 permissions by default.

Smart search

Full-text search with FTS5 when available, with automatic fallback to LIKE for environments without the FTS extension. Searches decision titles, reasons, discarded alternatives, commit messages and content-bearing events.

Automatic capture

A single unified hook (activity-capture.py) captures everything automatically: workflow events (iterations, phases), Git commits (SHA, message, author, files) and tool activity. Internal dispatch based on event type.

Integrated MCP server

15 tools accessible from any agent via MCP stdio: search, record, query iterations, statistics, iteration management, decision lifecycle, integrity validation, export/import. No external dependencies.

Session context

At the start of each session, relevant decisions are injected: if there's an active iteration, those from that iteration; if not, the latest 5 globally. A PreCompact hook protects these decisions during context compaction.

Built-in security

Secret sanitisation with the same patterns as secret-guard.sh: API keys, tokens, JWT, connection strings and private keys are redacted before storage. 0600 permissions on the database file.

The Librarian

Optional agent -- project memory

The Librarian is the agent that answers historical queries about the project. Unlike other agents that work on current code, this one focuses on the why of past decisions: what was decided, when, what alternatives were discarded and which commits implemented each decision. Since v0.2.3 it also manages the decision lifecycle (status, tags, relationships), validates memory integrity and allows exporting decisions to Markdown or importing from Git and ADRs.

It has an unbreakable rule: always cite sources. Every statement includes verifiable references with format [D#42] for decisions, [C#a1b2c3d] for commits and [I#7] for iterations. If it doesn't find evidence, it says so instead of making things up.

Example query:
> Why did we use SQLite instead of PostgreSQL for memory?
SQLite was chosen because the requirement was zero external dependencies [D#12]. The PostgreSQL alternative was discarded because it required an external service running [D#12, alternatives]. The implementation was done in commit [C#1833e83] within iteration [I#3].

Activation: enabled from /alfred-dev:config in the persistent memory section. Once active, Alfred automatically delegates historical queries that arise during any workflow.

Preguntas sobre la memoria

In the file .claude/alfred-memory.db inside each project root. It's a local SQLite file; nothing is sent to external services. Add it to .gitignore if you don't want to version it.
No. Activation is explicitly optional. It's enabled from /alfred-dev:config in the memory section. If you don't activate it, no database is created and nothing is captured.
All content goes through the same sanitisation used by the secret-guard.sh hook before being stored. API keys, tokens, JWT, connection strings and private key headers are automatically redacted. The database file has 0600 permissions (read/write only for the owner).
Yes. Simply delete the .claude/alfred-memory.db file. You can also deactivate memory from /alfred-dev:config: existing data is preserved but stops being queried and no new events are captured.
Getting started

Installation

One command in the terminal and you're set. Compatible with macOS, Linux and Windows. The installer is idempotent: running it again updates without conflicts. On the first session Alfred can bootstrap your local config and suggest the next step.

curl -fsSL https://raw.githubusercontent.com/686f6c61/alfred-dev/main/install.sh | bash
Requirements: git, Python 3.10+, Claude Code installed.
After installation, restart Claude Code and run /alfred-dev:alfred or /alfred-dev:help.
curl -fsSL https://raw.githubusercontent.com/686f6c61/alfred-dev/main/install.sh | bash
Requirements: git, Python 3.10+, Claude Code installed.
After installation, restart Claude Code and run /alfred-dev:alfred or /alfred-dev:help.
irm https://raw.githubusercontent.com/686f6c61/alfred-dev/main/install.ps1 | iex
Requirements: git, PowerShell 5.1+ (pre-installed on Windows 10/11), Claude Code installed.
Python not required. After installation, restart Claude Code and run /alfred-dev:alfred or /alfred-dev:help.
Alternative: you can also use the bash installer with WSL or Git Bash.

Uninstallation

To completely remove Alfred Dev, run the uninstaller for your platform. It cleans up all plugin registries and directories.

macOS / Linux

curl -fsSL https://raw.githubusercontent.com/686f6c61/alfred-dev/main/uninstall.sh | bash

Windows (PowerShell)

irm https://raw.githubusercontent.com/686f6c61/alfred-dev/main/uninstall.ps1 | iex

Update

From Claude Code, run /alfred-dev:update to check for a new version. If available, Alfred shows the release notes and asks if you want to update. You can also re-run the installer: it's idempotent.

Customisation

Per-project configuration

Each project has its own configuration file at .claude/alfred-dev.local.md. The first session can generate it automatically with a CLI-friendly baseline; afterwards /alfred-dev:config lets you review and expand it with autonomy, optional agents and persistent memory. The file syntax currently follows Alfred's Spanish key names because it mirrors the plugin schema.

alfred-dev.local.md
---
autonomia:
  producto: autonomo
  arquitectura: autonomo
  desarrollo: autonomo
  calidad: autonomo
  documentacion: autonomo
  entrega: autonomo

agentes_opcionales:
  data-engineer: false
  ux-reviewer: false
  performance-engineer: false
  github-manager: false
  seo-specialist: false
  copywriter: false
  librarian: false
  i18n-specialist: false

memoria:
  enabled: true
  sync_to_native: true
  sync_commits_limit: 10
  capture_decisions: true
  capture_commits: true
  retention_days: 365

personalidad:
  nivel_sarcasmo: 3
  celebrar_victorias: true
  insultar_malas_practicas: true
---

Automatic bootstrap

If a project has no local config yet, Alfred can generate .claude/alfred-dev.local.md automatically during the first session so the plugin is usable from CLI without manual prep.

Operational autonomy

Control how much intervention you need at each phase or slice of the workflow. In autonomous mode Alfred reduces unnecessary interviews and prioritises continuity, brownfield mapping and next-step guidance before opening a full team.

Optional agents

Activate only the ones you need. Alfred analyses your project and suggests which to enable based on the detected stack. They can be changed at any time without reinstalling.

Memory and context

Persistent memory and continuity artifacts coexist: decisions in a per-project SQLite database, plus handoff, UAT and operational docs in docs/project/ so work can resume without losing the thread.

Personality

Sarcasm level goes from 0 (formal professional) to 5 (sharp with affection). Celebrations and bad-practice warnings are toggled separately.

Frequently asked questions

FAQ

Yes. Alfred Dev has a native PowerShell installer for Windows 10/11. You can also use the bash installer through WSL (Windows Subsystem for Linux) or Git Bash. The only dependency on Windows is git; python3 is not required.
On macOS and Linux: git and python3. Both are usually pre-installed or easy to install with the system package manager.

On Windows: just git. PowerShell handles JSON natively, so python3 is not needed. PowerShell 5.1+ comes pre-installed on Windows 10/11.
Run /alfred-dev:update inside Claude Code. The command queries GitHub, compares versions and shows the release notes if a new version is available. You can also re-run the installer: it overwrites the previous version without conflicts.
If the project already has code but does not yet have a persistent map, Alfred prioritises /alfred-dev:map-codebase. It analyzes the structure, detects the stack, entrypoints, risks and conventions, and leaves the context in docs/project/codebase-map.md and docs/project/current.md before opening feature, fix, spike or audit.
/alfred-dev:quick is for small, local, bounded changes: two lightweight phases, tests for the touched area and quick security review. /alfred-dev:feature is for new functionality or changes that cross domains, need a PRD, architecture decisions or a full product-to-delivery cycle.
Yes. /alfred-dev:pause stores the current state in .claude/alfred-handoff.json and docs/project/handoff.md. Later you can come back with /alfred-dev:resume or simply ask for /alfred-dev:next. Alfred restores the workflow, current phase, pending gate and exact next step.
/alfred-dev:verify closes human validation for a deliverable. Automatic tests tell you whether the system works technically; verify records whether it actually meets the user's expectation in UAT. The state is tracked as pending, approved or rejected in .claude/alfred-uat.json and docs/project/uat.md.
/alfred-dev:progress makes the project's operational state visible: active workflow or handoff, general progress, kanban, blockers, traceability and UAT state. It does not open new work or force a gate; it helps decide what should happen next based on real context.
SonIA is no longer only an internal board manager. /alfred-dev:standup, /alfred-dev:blocked, /alfred-dev:in-progress, /alfred-dev:validate and /alfred-dev:search turn that state into a daily operational CLI interface.
No. /alfred-dev:sync-github runs SonIA Sync as a collaboration mirror for issues. The source of truth stays local: docs/project/, .claude/ and the project's SQLite memory.
/alfred-dev:memory-ui opens a local browser view on top of the project's real SQLite memory. Use it when you want to quickly understand what happened, which decisions are recorded, which commits were captured, how continuity is going or whether memory is healthy, without reading the database by hand.
Not necessarily. On the first session Alfred can bootstrap .claude/alfred-dev.local.md with a baseline configuration that is already usable from CLI. Afterwards you can fine-tune autonomy, optional agents, memory and personality with /alfred-dev:config.
Yes. Alfred Dev coexists without conflicts with other installed plugins. It uses its own namespace (alfred-dev) and doesn't interfere with other plugins' configuration.
They are 8 specialised agents you can activate based on your project's needs: data-engineer (databases), ux-reviewer (accessibility and usability), performance-engineer (performance), github-manager (repository management), seo-specialist (web positioning), copywriter (text and spelling), The Librarian (persistent memory: historical queries about project decisions, commits and iterations) and The Interpreter (internationalisation: i18n key audit, hardcoded string detection, per-locale format validation).

Alfred analyses your project and suggests which to activate. You can also manage them manually with /alfred-dev:config. They are activated or deactivated without reinstalling anything.
60 skills distributed across 13 domains. The original 7 domains (product, architecture, development, security, quality, DevOps, documentation) cover the standard lifecycle. The 6 new ones (data, UX, performance, GitHub, SEO, marketing) correspond to the optional agents. Existing domains have also been expanded: documentation went from 4 to 9 skills, security from 5 to 6, and quality from 4 to 6.
It's a local SQLite database that stores each project's decisions, commits and iterations. Optionally activated from /alfred-dev:config. Once active, Alfred automatically records workflow events and the Librarian agent can answer historical queries like "why was this architecture chosen" or "what was done in the last iteration", always citing sources. Data stays within the project: everything is kept in .claude/alfred-memory.db.
Nothing. Alfred Dev is free software under the MIT licence. You can use, modify and distribute it without restrictions. The source code is on GitHub (github.com/686f6c61/alfred-dev).
Spanish (Spain) by default: both responses and code comments, commits and generated documentation. You can adjust this behaviour with /alfred-dev:config.
Any version of Claude Code that supports the plugin system. If you can install plugins from the command line, Alfred Dev will work. There is no specific minimum version requirement.
Yes. Alfred Dev is free software under the MIT licence. You can report bugs, propose improvements or submit pull requests on the GitHub repository (github.com/686f6c61/alfred-dev/issues). Code, documentation, translation contributions or simply reporting issues are welcome.
Yes, like any interaction with Claude. Agents are system instructions that guide responses, so they consume context proportional to their complexity. In practice, the additional cost is moderate: agent system prompts are optimised to take up as little space as possible without losing precision. Optional agents are only loaded if you activate them, so the base context is that of the 10 core agents.
Alfred detects the stack of the current working directory, not the repository root. If you run Claude Code from a monorepo root, it will detect all languages present. If you run it from a specific package, it will focus on that package. Persistent memory is per working directory, so each package can have its own decision database if you configure it that way.
The workflow stops at the current phase and Alfred explains what failed: failing tests, detected vulnerabilities, incomplete documentation or whatever applies. You have three options: fix the issue and retry the gate, ask Alfred to help resolve it (for example, with /alfred-dev:fix if it's a bug), or continue manually accepting the risk. Alfred never advances silently if a gate fails.
It's in development. OpenCode is an open-source terminal-based code editor that shares the plugin architecture with Claude Code. Alfred Dev is being adapted to be compatible with both environments. The OpenCode version will be announced in the repository when it's ready for general use.