An AI team by your side, from idea to code. ARchetipo turns isolated AI prompts into a complete product development process with specialized roles and persistent artifacts.
ARchetipo is a method to build with AI without chaos. It does not replace an AI assistant: it gives the assistant a sequence of clear steps to follow instead of asking everything in one shot.
ARchetipo follows a spec-driven approach: first the team writes what it wants to do and how, then it implements it. The specification guides the code, not the other way around.
ARchetipo produces documents, not only conversations. Each phase leaves a document that can be read, reviewed and shared, avoiding decisions scattered across many chats.
ARchetipo works with the tools you use: with a plugin system, it adapts to GitHub, Jira, Figma and can be used by any AI agent.
ARchetipo is based on a structured workflow in five phases, from inception to implementation. The process turns an idea into a product through backlog writing, planning and implementation, one phase at a time. Each phase has a clear purpose: start from an idea, turn it into requirements, then into a plan, and finally into code. One after the other for a new project, or as a loop for every new feature.
Inception: define the product. Result: product document. Inception is a guided conversation to turn an idea into a clear, shared product document.
Design: design the experience. Result: product mockup. Design creates product mockups after Inception, or during Plan for each story.
Spec: split into stories. Result: project backlog. Spec turns the product document into the list of things to do: epics, stories and priorities, ready to be planned.
Plan: plan the work. Result: plan for each story. For every story, Plan creates a concrete work plan: what to change, how to do it, what to test. It is written before touching the code.
Implement: build and review. Result: story ready for review. Implement turns the plan into code, tests and review. The story arrives ready to be checked and approved.
Eight specialists, one team: isolated prompts do not build products. ARchetipo introduces a workflow inspired by real teams, with specialized roles and persistent artifacts - PRD, backlog, plans, mockups - that move from one phase to the next without getting lost. Behind each phase there is not a generic assistant, but a team of agents with distinct roles. Each one contributes when its expertise is needed, then hands over to the next.
Andrea, Product Manager: keeps the direction. Andrea turns ideas into clear goals and keeps the product coherent over time. Skills: INCEPTION active, SPEC, PLAN, IMPL.
Costanza, Strategist: looks at the context. Costanza investigates users, market and scenarios so the product solves a real problem. Skills: INCEPTION active, SPEC, PLAN, IMPL.
Leonardo, Architect: designs the foundations. Leonardo chooses stack, modules and boundaries so the project remains solid as it grows. Skills: INCEPTION, SPEC, PLAN active, IMPL.
Livia, UX Designer: thinks about the experience. Livia sketches flows and screens so the solution is clear before it becomes code. Skills: INCEPTION, SPEC, PLAN active, IMPL.
Emanuele, Requirements Analyst: translates ideas into requirements. Every story arrives with explicit details and acceptance, no ambiguity. Skills: INCEPTION active, SPEC active, PLAN active, IMPL.
Ugo, Full-Stack Developer: works on the code. Ugo executes the plan with order, respecting conventions and architectural choices. Skills: INCEPTION, SPEC, PLAN active, IMPL active.
Mina, Test Architect: thinks about tests before code. Mina defines what must be verified and how, at multiple levels. Skills: INCEPTION, SPEC, PLAN active, IMPL active.
Cesare, Code Reviewer: performs the final check. Cesare reads with critical eyes, looks for inconsistencies and returns clean work. Skills: INCEPTION, SPEC, PLAN, IMPL active.
Each skill can be used in isolation, but together they form the complete delivery cycle for a story. They detect the language of the conversation and produce persistent artifacts.
ARchetipo is iterative and intentional. Inception defines the scope. Then the loop starts: each round enriches the backlog, plans the next story and implements it. Design joins whenever new UI is needed.
Workflow diagram image: `images/archetipo_iterative.png`.
For Product Managers: ARchetipo provides velocity, because it moves from idea to backlog in hours, not days; structure, because it creates complete PRDs and automatically prioritized backlogs; traceability, because it connects vision to implementation with persistent artifacts.
For Developers: ARchetipo provides clarity, because technical plans are written before code; quality, because the test strategy is defined upfront and is TDD-ready; focus, because it reduces context switching.
For Teams: ARchetipo provides alignment through one source of truth (PRD, backlog, plans); scalability through a repeatable workflow across projects; autonomy because AI handles execution while humans validate decisions.
Start building your product with AI today. TechReloaded helps with setup and custom configuration around existing processes and tools.
Training: TechReloaded consultants train teams and help them practice operational workflows.
Tool customization: TechReloaded can develop proprietary connectors for tools such as Jira, ServiceNow and other enterprise systems.
GitHub repository: source code, releases and issues for the project. It is the starting point to download ARchetipo, follow its evolution and contribute. Link: GitHub repository.
Examples and tutorials: practical examples and guided paths to see ARchetipo in action on real cases and learn the workflow step by step. Link: Examples and tutorials.
ARchetipo is a set of Markdown skills that turns an AI coding agent into a product team. Supported agents include Claude Code, Codex, Gemini CLI, OpenCode and GitHub Copilot. The skills read `.archetipo/config.yaml` to know where to save artifacts, then operate through abstract connectors.
ARchetipo is installed through npm. Once the CLI is installed, `archetipo init` shows an interactive menu to choose the target AI tools.
npm i -g @techreloaded/archetipo
archetipo initNon-interactive initialization example:
archetipo init --tool claude --connector fileWhat `archetipo init` does: it shows an interactive menu to choose which AI tools should receive the skills; it copies each skill into the selected tool directory, such as `.claude/skills/` or `.gemini/skills/`; it creates `.archetipo/config.yaml` with the selected connector, using `file` by default; it creates `.archetipo/shared-runtime.md`.
macOS and Linux require `curl` and `unzip`, usually available by default. Windows requires PowerShell 5.1 or higher. The GitHub connector requires the `gh` CLI authenticated with `repo` and `project` permissions.
After installation, use ARchetipo from the AI coding agent through slash commands. Each command invokes a skill that produces persistent artifacts and feeds the next phase.
Step 1: define the product with `/archetipo-inception`. Output: `docs/PRD.md`.
Step 2: optionally create visual concepts with `/archetipo-design`. Output: `docs/mockups/`.
Step 3: generate the initial backlog with `/archetipo-spec`. Output: `docs/BACKLOG.md`.
Step 4: plan a story with `/archetipo-plan US-001`. Output: `docs/planning/US-001.md`.
Step 5: implement a story with `/archetipo-implement US-001`. Output: code, tests, code review and story state moved to `REVIEW`.
Alternative autonomous execution: use `/archetipo-autopilot` to coordinate progress across multiple stories through the `plan -> implement` cycle.
Language auto-detection: each skill adopts the language of the conversation. Write in Italian to get Italian artifacts. Write in English to get English artifacts.
PRD: Product Requirements Document. It defines what to build, for whom and why.
Backlog: ordered list of user stories to implement, each with priority, estimate and state.
User story: atomic requirement from the user's point of view.
Epic: group of related user stories with a shared goal.
Planning file: technical document for a single story with solution, ordered tasks, dependencies and test strategy.
INVEST: quality criteria for user stories: Independent, Negotiable, Valuable, Estimable, Small, Testable.
Acceptance criteria: verifiable conditions that define when a story can be considered complete.
Backend: artifact storage mode. ARchetipo can save artifacts as local Markdown files or through GitHub Projects v2 and Issues.
The six skills are chained into a delivery-oriented sequence. Each skill produces artifacts consumed by the next one. ARchetipo implements Spec-Driven Development: the specification is the contract, and the `spec -> plan -> implement` cycle repeats for every value slice until the product is complete.
`archetipo-inception`: discovery and product definition. It guides discovery with a virtual team, collects goals, scope and business assumptions, then produces the PRD.
`archetipo-design`: optional UI mockups and prototypes. It produces isolated HTML/CSS mockups in `docs/mockups/` without touching application code.
`archetipo-spec`: backlog creation and extension. It converts the PRD into a backlog or adds new INVEST-compliant stories to an existing backlog.
`archetipo-plan`: technical implementation plan. It turns a TODO story into a technical plan with solution, ordered tasks, dependencies and test strategy.
`archetipo-implement`: code and test writing. It executes the technical plan: writes code, writes tests, performs automatic code review and moves the story toward `REVIEW`.
`archetipo-autopilot`: autonomous execution of the `plan -> implement` cycle across multiple stories using isolated subagents.
`TODO`: story in the backlog, not started. Transition: automatic, from spec.
`PLANNED`: technical planning completed. Transition: automatic, from plan.
`IN PROGRESS`: implementation in progress. Transition: automatic, from implement.
`REVIEW`: code review and tests passed, ready for human approval. Transition: automatic, end of implement.
`DONE`: story accepted and released. Transition: manual.
If there is no PRD, start with `archetipo-inception`.
If visual concepts are needed before development, use `archetipo-design`.
If there is no backlog with user stories, use `archetipo-spec`.
If stories are not planned, use `archetipo-plan`.
If multiple stories are ready to process, use `archetipo-autopilot`; otherwise use `archetipo-implement` one story at a time.