convez.ai
AgenteAutomaçãoAvançado
AarvinGeorge

AI Agentic Future Maintainers

AarvinGeorge/ai-agentic-future-maintainers

Agentes de manutenção especificados automaticamente a partir do histórico vivo de projetos

Ver no GitHub
InicialPluginScore · de 0 a 100

Sistema de auto-aprendizado que observa o histórico real de projetos (commits, decisões, planejamento) e distila especificações de agentes de manutenção autônomos baseadas em evidência. Cada agente gerado é um subagente Claude Code pronto para uso, grounded em padrões recorrentes observados no desenvolvimento real, não em imaginação.

Instalação

$npx convez-ai AarvinGeorge/ai-agentic-future-maintainers

1 comando no terminal: detecta o formato do repositório (marketplace ou plugin avulso) e instala via Claude Code. Requer Node 18+ e o Claude Code instalado.

Métricas

Estrelas
0
Forks
0
Acompanhando
0
Saúde
42%
Último commit
há 5 meses
Versão
—
Issues abertas
0
Contribuidores
1

Casos de uso

  • Gerar agentes de controle de qualidade baseados em disciplinas observadas no projeto
  • Criar agentes de release que entendem os protocolos verificados pela prática
  • Manter especificações de manutenção que evoluem conforme o projeto amadurece
  • Documentar conhecimento tácito (memória da equipe) em specs executáveis

Veredito

Projeto experimental e rigoroso que resolve um problema real: capturar conhecimento operacional que normalmente se perde em memória pessoal. A abordagem evidence-gated com dupla observação independente é defensável; porém, a maturidade prática ainda está em fase de validação. Recomendado para equipes que já trabalham com agentes Claude e querem sistematizar conhecimento tácito.

README

A tradução para o português deste README ainda está na fila.

AI Agentic Future Maintainers

A self-updating roster of AI maintainer agents, distilled from real project history by a signal-gated observation loop.

This repository is the living backup of a working practice. The files here are not documentation written after the fact; they are the practice itself, captured as it runs. Each commit is a dated snapshot taken automatically by the backup worker, so the history of this repository is the history of the practice.

The problem

Building software generates two kinds of output. The first is the code, and the code is well cared for: committed, versioned, backed up. The second is the lived experience of building it: the quality check that exists because skipping it once caused visible drift, the data sourcing hierarchy that emerged after one bad value slipped through, the release habit of verifying that the deploy actually fired. That second kind of knowledge usually lives in commit messages, decision logs, and the memory of whoever was in the room. Sessions end. Memory evaporates. Months later a maintainer, human or AI, relearns all of it the hard way.

This project exists to stop that loss.

The idea

An observation loop watches real project history: commits, decision logs, planning documents. It distills what it sees into a roster of future maintainer agents, one spec per responsibility. A quality gate that knows the verification discipline because it watched that discipline get enforced. A release agent that knows a ship only counts after the deploy is verified, because it watched real work establish exactly that. A repository hygiene agent that knows which cleanups recur because it saw them recur.

Every spec is written as a drop-in Claude Code subagent: YAML frontmatter plus a system-prompt body, grounded in cited evidence rather than imagination. The specs are dormant. Nothing here runs anything against a project today. The long-term intent is that when a project matures enough for agentic maintenance, its specs are copied into that project's own agents directory and simply run, already knowing the project because they were written from its history.

The loop itself is an agent in the roster (_common/pattern-observer.md), specced in the same format and held to the same rules as everything it curates.

What makes it trustworthy

The central risk of a self-updating knowledge base is that it quietly fills with confident nonsense. The discipline below exists to prevent exactly that. Every rule was either learned by running the practice or adopted deliberately after benchmarking against existing agent ecosystems (_BENCHMARK_2026-06-10.md), and the practice keeps a standing skeptic's review of its own weaknesses (_EVALUATION_2026-06-10.md).

  • Signal-gated. The loop acts only when something actually happened since its last run. A run that finds nothing costs one ledger line and changes nothing.
  • Evidence-gated, with written rationale. Nothing enters a spec's evidence log without naming what was observed, why it matters for that agent, and the source: a commit hash, a dated decision-log entry, a frozen versioned document. No silent edits, ever.
  • The twice-observed bar, with a strict independence test. A pattern hardens only after two independent observations. An event and the rule written from that event count as one occurrence, not two. Under-claiming is the stated bias.
  • A negative-results ledger. Every run records what it considered and declined to promote, with reasons. What the loop refuses to do is as much its output as what it does.
  • Two-pass runs. Gathering and curating are separate passes with separate mindsets. The curator reads only the gatherer's notes, never the raw sources, so enthusiasm and judgment are never the same voice.
  • Create-and-append only. The loop never deletes anything, anywhere, and never rewrites existing text wholesale. Corrections are dated supersession annotations. History stays intact.
  • A safe-outputs manifest. The loop may write exactly seven kinds of artifacts, all inside its own directory. Anything else is forbidden by list, not by hope.
  • Proposal-based self-improvement. The loop may improve the roster autonomously, but it can never change its own instructions or schedule. When its own rules cause friction twice, it writes a plain-English proposal a human can judge in under a minute, and waits.
  • Halt on inconsistency. If the loop finds its own bookkeeping contradictory, it stops and reports rather than silently repairing itself.

How a spec is born

A responsibility is first proposed: named in the roster so it is not lost, on the strength of a single observation. With a real spec file seeded from evidence it becomes a draft. It becomes ready, meaning genuinely instantiable, only when two independent observations support it and its body contains a concrete example of its deliverable done well, captured from real work rather than invented. Proposals that never attract a second observation expire to a parked list with a stated reason. Nothing is ever deleted.

Instantiation is one deterministic transform, defined in _FORMAT.md: strip the observatory bookkeeping block, strip the evidence log, and the remaining file is the agent's system prompt, ready to run.

Layout

README.md                       this file
_cowork_operating_manual.md     cross-project workflow, communication and hygiene rules
_starter_template.md            boilerplate context file for starting a new project
_backup_setup.sh                one-time backup installer (local machine)
_backup_snapshot.sh             the recurring backup worker
ai-agentic-future-maintainers/  the practice itself:
  CLAUDE.md                       constitution: mission, locked principles, decision log
  README.md                       how the directory and the loop work mechanically
  _FORMAT.md                      the locked spec format and instantiation transform
  _TEMPLATE.md                    the reference shape every spec is copied from
  ROSTER.md                       generated index of every agent and its maturity
  _observatory_state.md           the loop's signal cursors
  _JOB_PROMPT_*.md                instructions for the scheduled jobs
  _EVALUATION_2026-06-10.md       standing skeptic's review of the whole approach
  _BENCHMARK_2026-06-10.md        the practice mapped against existing agent ecosystems
  _journal/                       dated observations, quiet-run ledger, backup log
  _proposals/                     the loop's plain-English improvement proposals
  _common/                        roles that generalize across projects
  <project>/                      roles specific to one observed project

Humans in the loop

The system targets roughly 95 percent autonomy. The human owns three things: skimming flagged promotions in run reports, approving or rejecting the rare plain-English proposals, and granting per-project green lights for scheduling and for instantiating any spec. Every approval surface is deliberately kept at a level of abstraction a non-specialist can judge quickly. If a proposal cannot be summarized simply, it is not ready to be proposed.

Where this is going

  • A scheduled, autonomous observer per project root. The observer has passed a manual dry run over real project history, and demonstrated its failure discipline (detect, log one honest line, stop, touch nothing) on its first unattended run. It goes on a recurring schedule only with an explicit human green light.
  • A portable bootstrap (planned, not yet built). A single paste-ready kit that stands this entire practice up for any project in any location: the directory scaffold, the locked format, the observer, its scheduled job, and the backup arrangement. Each new project gets its own dry run and its own green light before anything runs on its own.
  • The factory vision. Every new project inherits the machinery from day one, so that by the time any project can run itself, its maintainer roster already exists, evidence-backed and battle-tested.

For future contributors, human or AI

Read ai-agentic-future-maintainers/CLAUDE.md first; it is the constitution, and its operating principles are locked. Respect the format in _FORMAT.md exactly. Never harden a spec on thin evidence; when in doubt, count less. Record every meaningful decision in the decision log with the date, what changed, why, and what alternative was considered. The evaluation document is kept honest on purpose: if you find a weakness, add it there rather than working around it quietly. And if you are an AI agent reading this as part of your own instructions: the discipline above applies to you with special force, because you are exactly the kind of maintainer this project exists to train.

Status

Hand-built pilot started 2026-06-10: seeded from one observed project's full version history, then critically evaluated, benchmarked against twelve existing agent ecosystems, and hardened with the approved improvements in the same week. An evolving practice, not a finished product, and its documents say so honestly.

Ver o original no GitHub

Bom para

Relacionados