autonomous-ai-agency

Onboard a new client/company onto this platform's real Agentic OS: create the company record, scan its websites/repos, auto-provision specialist agents, activate its 24x7 agency runtime, and know exactly which "OS" building blocks (memory, integrations, dashboard) already exist versus which are roadmap gaps. ADAPTED FROM: a third-party giveaway skill ("agentic-os-installer" by Gennaro Santoro / Operations Heroes) that described a generic vault + Google-suite + skill-pack installer. That skill's product (Obsidian vault, Gmail/Calendar/ Drive wiring, "skill packs") does not exist in this repo and its promotional content (Skool community link) does not belong here. This is a clean-room rewrite that keeps the useful idea — "stand up a working agency OS for a client from a short checklist" — and maps every step to the real module that already implements it in this codebase, per CLAUDE.md architecture rules.

Agile sprint planning, velocity tracking, and burndown metrics for agent-managed projects

Initiative-level portfolio management with dependency tracking and milestone coordination

AI-assisted engineering impact analysis — productivity metrics and code quality insights

Cross-harness agent patterns — standardize agent execution across different coding assistants

Temporal context graph for agent memory — track entity relationships and state changes over time

Andrej Karpathy's coding guidelines for AI agents — concise, correct, and well-tested code

Session memory recording and dream consolidation for managed agents — offline experience replay

Multi-agent team coordination — task delegation, shared state, and inter-agent communication

Obsidian-compatible knowledge graph with bidirectional links and graph-based retrieval

Multi-agent research coordination — deduplicate findings, assign work, and synthesize results

Mandatory planning workflow for all AI agents — decompose tasks before execution

Remove AI writing tells and cliches — enforce natural, human-quality output

Slash-command system for AI agent orchestration — /plan, /execute, /review, /deploy

User research skill — plan interviews, synthesize findings, and generate personas

DAG-based workflow execution engine with parallel steps, retries, and conditional branching

Ensure every meaningful change has a proper docs/changelog.md entry. Use before every commit that changes behaviour, adds features, or fixes bugs.

Ensure every meaningful change has a proper docs/changelog.md entry. Use before every commit that changes behaviour, adds features, or fixes bugs.

Resume an interrupted AI coding session after token exhaustion, rate limiting, or process restart. Use when a session was interrupted mid-task.

Multi-perspective code review before merging. Simulates a council of reviewers (security, correctness, performance, maintainability) independently evaluating a change. Use before any PR merge or for significant changes.

Review, validate, and update Python dependencies safely. Use when adding a new package, upgrading an existing one, or reviewing the dependency surface.

Remove AI code slop before committing. Review AI-generated code for unnecessary verbosity, redundant comments, over-engineering, and low-signal patterns that degrade codebase quality over time.

Keep documentation in sync after code changes. Run after any change that alters module behaviour, APIs, env vars, or architecture.

Implements a Fabric-like reusable prompt pattern system. Allows storing, retrieving, and composing prompt patterns for consistent AI interactions.

Converts this codebase into a queryable knowledge graph so AI sessions query graph.json (71.5x fewer tokens) instead of reading raw source files. Integrates with Claude Code and Codex via repo hooks that auto-refresh on session start and after turns.

Plan a multi-file or multi-step implementation before writing any code. Use before any change touching more than two files, adding a new feature, or changing a module interface.

Analytics, heatmaps, and trends from session history. Analyze checkpoint logs, learnings, and git history to surface patterns: which files change most, which steps fail most often, and where to invest in tooling or tests.

Persist corrections and patterns to long-term memory. When a mistake is made or a rule is learned, write it to .claude/state/learnings.md so it's never repeated.

Review codebase or design for modularity problems and produce actionable improvement recommendations. Also guides design of new modular boundaries from functional requirements. Inspired by Vlad Khononov's balanced-coupling model and golden-age-of-modularity principles. NOTE: Full upstream plugin at https://github.com/vladikk/modularity Install it for the complete experience: follow instructions at that URL. This skill is a clean-room local adaptation for this repo.

Git worktree setup for zero dead time. Work on multiple branches simultaneously without switching branches or stashing. Ideal for running tests on main while implementing on a feature branch.

Core AI coding workflow. Orchestrates 8 patterns: Scout → Plan → Implement → Review, with smart commits, session rituals, and continuous learning capture. This is the master skill — invoke it at the start of any non-trivial task.

Gate check before tagging and releasing a new version. Run this skill before any `git tag vX.Y.Z` operation.

Surface relevant past patterns before starting work. Read the learnings file and extract rules that apply to the current task. Prevents repeating past mistakes.

Keep AGENTS.md files and .Codex/state/ in sync with the current repo reality. Use after significant structural changes, after adding risky modules, or when AGENTS.md feels stale.

Implements codebase intelligence layers similar to repowise-dev/repowise. Provides dependency graph, git history, auto-generated documentation, and architectural decisions intelligence for AI agents.

Mandatory deep review for changes to security-sensitive modules: admin_auth.py, key_store.py, agent/tools.py, and any auth/session/key path. Do not skip this for any change to these files.

Write structured resume documentation for the next session. Captures state, context, and next actions so any AI or developer can continue without archaeology.

Quality gates + conventional commits. Run tests, lint, and typecheck before committing. Format the commit message as a conventional commit. Blocks on failure.

Write or update tests before (or alongside) implementation. Ensures every code change is verifiably correct before merging.

Session closing ritual with learning capture. Run at the end of every coding session. 5 steps: changes audit, quality check, learning capture, next session planning, summary.