AI Software Factory | Sakaguchi IA

O que é este projeto

A AI Software Factory é um sistema de desenvolvimento de software enterprise orquestrado inteiramente por agentes de IA autônomos. Cada agente é especialista em uma etapa do ciclo de vida: análise de requisitos, arquitetura, codificação, testes e deploy.

O objetivo não é substituir desenvolvedores. É eliminar o trabalho repetitivo e mecânico para que engenheiros foquem em decisões de design, revisão crítica e inovação. O pipeline transforma descrições em linguagem natural em software funcional, testado e pronto para produção.

Human-in-the-loop: Em pontos críticos do pipeline — aprovação de arquitetura, revisão de código sensível e autorização de deploy — a fábrica pausa e aguarda validação humana. Nenhum código vai para produção sem revisão explícita de um engenheiro.

Arquitetura da fábrica

O pipeline é composto por cinco agentes especializados que trabalham em sequência. Cada agente recebe o artefato do anterior, processa e entrega ao próximo. Um orquestrador central coordena o fluxo, gerencia estados e implementa pontos de revisão humana.

Pipeline de agentes com pontos de revisão humana (REVIEW/APPROVE)

Agente analista

O agente analista é o ponto de entrada da fábrica. Ele recebe descrições em linguagem natural — um e-mail do cliente, um ticket do Jira, uma conversa gravada — e extrai requisitos estruturados. O resultado são user stories com critérios de aceitação prontos para consumo pelos próximos agentes.

Extração de requisitos — NLP para identificar funcionalidades, regras de negócio e restrições técnicas
Geração de user stories — formato padrão com persona, ação e benefício
Priorização automática — MoSCoW scoring baseado em dependências e complexidade
Detecção de ambiguidade — sinaliza requisitos vagos para esclarecimento humano

Exemplo: Pipeline de análise

# pipeline/agents/analyst.py
from langchain.agents import AgentExecutor
from langchain.prompts import ChatPromptTemplate
from factory.models import UserStory, RequirementSpec

class AnalystAgent:
    """Extrai requisitos de linguagem natural e gera user stories."""

    def __init__(self, llm, tools=None):
        self.llm = llm
        self.prompt = ChatPromptTemplate.from_messages([
            ("system", "Você é um analista de sistemas sênior. "
             "Extraia requisitos funcionais e não-funcionais."),
            ("human", "{input}")
        ])
        self.chain = self.prompt | self.llm

    def extract_requirements(self, raw_input: str) -> RequirementSpec:
        # Processa entrada em linguagem natural
        result = self.chain.invoke({"input": raw_input})
        return RequirementSpec.parse(result.content)

    def generate_stories(self, spec: RequirementSpec) -> list[UserStory]:
        # Gera user stories com critérios de aceitação
        stories = []
        for req in spec.functional:
            story = UserStory(
                persona=req.actor,
                action=req.description,
                benefit=req.business_value,
                acceptance_criteria=self._generate_criteria(req),
                priority=self._score_priority(req)
            )
            stories.append(story)
        return stories
                

Agente desenvolvedor

O agente desenvolvedor recebe a arquitetura aprovada e as user stories, e gera código funcional seguindo uma abordagem test-first. Antes de escrever qualquer implementação, ele gera os testes. Depois implementa até que todos passem.

Test-first development — testes são gerados antes da implementação, garantindo cobertura desde o início
Quality gates — lint, type checking e análise estática executados automaticamente a cada iteração
Refactoring automático — após os testes passarem, o agente refatora para reduzir complexidade
Documentação inline — docstrings e comentários gerados junto com o código

Exemplo: Orquestrador do pipeline

# pipeline/orchestrator.py
from factory.agents import AnalystAgent, ArchitectAgent
from factory.agents import DeveloperAgent, TesterAgent, DeployerAgent
from factory.review import HumanReviewGate

class FactoryOrchestrator:
    """Coordena o pipeline de agentes da fábrica de software."""

    def __init__(self, config):
        self.analyst = AnalystAgent(config.llm)
        self.architect = ArchitectAgent(config.llm)
        self.developer = DeveloperAgent(config.llm)
        self.tester = TesterAgent(config.llm)
        self.deployer = DeployerAgent(config.llm)
        self.review = HumanReviewGate(config.reviewers)

    async def run_pipeline(self, raw_input: str):
        # 1. Análise de requisitos
        spec = self.analyst.extract_requirements(raw_input)
        stories = self.analyst.generate_stories(spec)

        # 2. Design de arquitetura (aguarda revisão humana)
        architecture = self.architect.design(stories)
        await self.review.request_approval(
            stage="architecture",
            artifact=architecture
        )

        # 3. Geração de código (test-first)
        codebase = self.developer.implement(architecture, stories)

        # 4. Testes e qualidade (aguarda revisão humana)
        report = self.tester.run_suite(codebase)
        await self.review.request_approval(
            stage="code_review",
            artifact=codebase,
            test_report=report
        )

        # 5. Deploy (requer aprovação explícita)
        await self.review.request_approval(
            stage="deploy",
            artifact=codebase,
            environment="production"
        )
        result = self.deployer.deploy(codebase)
        return result
                

Pipeline CI/CD

Cada commit gerado pelos agentes passa por um pipeline de CI/CD completo. Testes automatizados, revisão de código por IA, análise de segurança e deploy com rollback automático em caso de falha.

Testes automatizados — unitários, integração e e2e executados em paralelo via GitHub Actions
Code review por IA — análise estática, detecção de vulnerabilidades e sugestões de melhoria
Staging automático — deploy em ambiente de staging para validação antes de produção
Rollback inteligente — monitoramento pós-deploy com rollback automático se error rate ultrapassar threshold
Canary deployment — tráfego gradual (5% > 25% > 50% > 100%) com métricas de saúde

Métricas de qualidade

A fábrica monitora continuamente a qualidade do código gerado. Cada artefato é avaliado contra métricas objetivas antes de avançar no pipeline:

Cobertura de testes — mínimo de 85% para avançar; o agente tester gera testes adicionais se necessário
Complexidade ciclomática — limite de 10 por função; funções complexas são decompostas automaticamente
Dívida técnica — score SonarQube monitorado; bloqueio de merge se a dívida aumentar
Duplicação de código — detecção de blocos duplicados com sugestão de abstração
Conformidade de estilo — black, isort e ruff aplicados automaticamente

Ponto de revisão humana: Mesmo com todas as métricas no verde, o pipeline não avança para produção sem aprovação explícita de um engenheiro. A IA propõe, o humano decide.

Como usar

Clone o repositório, configure os agentes com suas credenciais de LLM e execute o pipeline. Cada pasta contém:

pipeline/ — orquestrador e agentes especializados
factory/ — modelos de dados, schemas e utilitários
config/ — configuração de agentes, LLMs e ambientes
tests/ — testes do próprio pipeline
.github/workflows/ — CI/CD com GitHub Actions

# Setup e execução
$ git clone https://github.com/Richardmsbr/ai-software-factory
$ cd ai-software-factory
$ python -m venv .venv && source .venv/bin/activate
$ pip install -r requirements.txt

# Configure os agentes
$ cp config/agents.example.yaml config/agents.yaml
$ vi config/agents.yaml  # adicione suas API keys

# Execute o pipeline
$ python -m pipeline.run --input "Criar sistema de autenticação com OAuth2"
                

Fábrica de software com agentes de IA autônomos

O que é este projeto

Arquitetura da fábrica

Agente analista

Exemplo: Pipeline de análise

Agente desenvolvedor

Exemplo: Orquestrador do pipeline

Pipeline CI/CD

Métricas de qualidade

Como usar

Tecnologias

Detalhes

Índice

Quer algo parecido?

Quer implementar algo parecido?