Technical Specification: Agentic Developer Platform (ADP)
The Agentic Developer Platform (ADP) is a unified, multi-team automation framework designed to bootstrap, govern, and scale AI-assisted engineering workflows across the enterprise. Built and scaled within a rapid 4-week timeline, the platform standardizes the deployment of advanced LLM tooling (Claude Code, Model Context Protocol (MCP) servers, custom agents, and specialized skills).
The platform bridges the gap between raw LLM capabilities and isolated team workflows, enabling development squads to inherit deep metadata footprints with zero manual configuration. It currently supports 20+ Global Skills, 20+ Autonomous Agents, and 20+ Active Teams, with initial onboarding executed across 7 pilot engineering squads in partnership with management.
🏗️ System Architecture Diagram
┌────────────────────────────────────────────────────────────────────────┐
│ DEVELOPER WORKSTATION / MACBOOK │
└───────────────────────────────────┬────────────────────────────────────┘
│
Executes: sh install_platform.sh
│
▼
┌────────────────────────────────────────────────────────────────────────┐
│ 1. INITIALIZATION & PREREQUISITE VERIFICATION GATE │
├────────────────────────────────────────────────────────────────────────┤
│ • Node.js & Tool Checks • Claude Code Status • Local User Configs │
│ • Git Connection Status • Playwright Browser • Extension Audits │
└───────────────────────────────────┬────────────────────────────────────┘
│
▼
┌────────────────────────────────────────────────────────────────────────┐
│ 2. MULTI-TENANT TEAM SELECTOR & ENGINE │
├────────────────────────────────────────────────────────────────────────┤
│ • Create Net-New Team Profile OR • Select Existing Team Profile │
└───────────────────────────────────┬────────────────────────────────────┘
│
▼
┌────────────────────────────────────────────────────────────────────────┐
│ 3. CONTEXT ENRICHMENT & METADATA HARVESTING LAYER │
├────────────────────────────────────────────────────────────────────────┤
│ Team Setup Skill Execution │
│ ┌──────────────────────────┴──────────────────────────┐ │
│ ▼ ▼ │
│ MCP Server Calls (APIs) User Guided Input │
│ [Fetches: Repo Paths, Feature Branches, SNOW Assignment Groups, Logs] │
└───────────────────────────────────┬────────────────────────────────────┘
│
▼
┌────────────────────────────────────────────────────────────────────────┐
│ 4. PERSISTENT STORAGE & SYMLINKING ENGINE │
├────────────────────────────────────────────────────────────────────────┤
│ • Writes /teams/<team_name>/config.json (Structured Metadata) │
│ • Writes /teams/<team_name>/context.md (Human-Readable Context) │
│ • Symlinks Team Markdown Profile Directly Into: .claude/rules/ │
└───────────────────────────────────┬────────────────────────────────────┘
│
┌────────────┴────────────┐
▼ ▼
┌──────────────────────────────┐ ┌──────────────────────────────┐
│ 5. AUTOMATIC RUNTIME │ │ 6. BACKGROUND OPERATIONS │
├──────────────────────────────┤ ├──────────────────────────────┤
│ • Claude Code Starts │ │ • MacBook Cron Auto-Updates │
│ • Automatic Rules Injection │ │ • Git-Based Issue Telemetry │
└──────────────────────────────┘ └──────────────────────────────┘🚀 Core Platform Components & Capabilities
1. Zero-Friction Bootstrapping (install.sh)
The platform features an automated configuration script that validates environmental dependencies, removing manual engineering setup time:
- Runtime Verification: Checks for operational Node.js environments, local system variables, and active git repositories.
- Tooling Audits: Verifies the active installation status of Claude Code, MCP configuration links, and auxiliary plugins.
- Symlink Engine: Automatically links centralized skills, agents, and rules inside the repository, ensuring zero configuration drift.
2. Multi-Tenant Team Subsystems & Context Injection
The core differentiator of the platform is its multi-team architecture, recognizing that engineering squads work on isolated feature branches, code repositories, or specific assignment groups.
- The Team Setup Skill: An orchestrator skill that aggregates team boundaries via automated MCP inquiries or guided terminal prompts.
- Dual-File Storage: Stores metadata under specialized team directories:
config.json: Structured properties built for programmatic lookup.context.md: Human-readable technical descriptions optimized for language model token ingestion.
- Automatic Rule Injection: The active team's
.mdfile is automatically symlinked straight into the local.claude/rules/workspace directory. When Claude Code initializes, it injects the team profile natively into the execution prompt context without requiring manual text flags.
3. Playwright Automation Integration
To bypass limitations where official API/MCP endpoints are missing or locked down, the platform packages a pre-configured Playwright CLI wrapper:
- UI Test Generation: Empowers Claude Code to natively write and spin up automated End-to-End browser interface tests.
- Instance Debugging: Allows the LLM to programmatically spin up headless browser instances to scrape internal dashboards, extract execution runtime flags, and read system console errors.
4. Lightweight GitHub Telemetry & Maintenance
The platform prioritizes metadata privacy while ensuring platform usage stats are collected transparently:
- Minimalist Tracking Schema: Telemetry payloads capture only critical execution fields to determine platform adoption metrics:
{
"user": "developer_identifier",
"folder_where_invoked": "/Users/dev/repo/subfolder",
"skills": ["git_helper", "db_schema_mapper"],
"team_name": "squad_delta",
"time_stamp": "2026-08-01T11:38:00Z"
}- Serverless Reporting Pipeline: Telemetry details are safely posted as lightweight payloads to a centralized GitHub Issues repository to measure onboarding rates, identify high-frequency skills, and trace user activity.
- MacBook Automation Crons: Transparent macOS background cron jobs run automatically to pull downstream config patches, preventing local custom prompts from falling behind master branches.
📊 Onboarding & Platform Metrics
- Development Velocity: Core infrastructure designed, tested, and shipped in 4 weeks.
- Operational Scale: Fully models and contains over 20+ Skills, 20+ Dedicated Agents, and 20+ Configured Team Ecosystems.
- Enterprise Expansion: Demonstrated and successfully deployed to 7 initial engineering teams in coordination with management, establishing cross-organizational buy-in.