how-to-guide

What Code Examples Are Included in Agent Technical Deliverables?

March 9, 2026 msitarzewski/agency-agents ↗

Agent technical deliverables in the Agency-Agents repository contain concrete, ready-to-run code snippets in TypeScript, JavaScript, Python, SQL, Bash, and Markdown that serve as reference implementations, automation templates, and testing harnesses.

The msitarzewski/agency-agents repository defines specialized AI agents through markdown files that specify expected outputs. Each agent's technical deliverables section includes fenced code blocks demonstrating exactly what the agent should produce, ranging from full application skeletons to configuration snippets.

Overview of Technical Deliverables Structure

Every agent file in the repository follows a consistent pattern. Immediately after the "## 📋 Your Technical Deliverables" header, you will find one or more fenced code blocks with language specifiers. These snippets serve three distinct purposes:

Reference Implementation – A minimal, functional piece of code demonstrating the pattern the agent should emit
Template for Automation – Copy-pasteable snippets wrapped in language-specific fences for downstream tooling
Testing and Validation Aid – Executable scripts or queries that developers can run to verify agent outputs

Code Examples by Agent Type

Developer Advocate Deliverables

The specialized/specialized-developer-advocate.md file contains three distinct code examples spanning documentation, CLI scaffolding, and interactive demos.

DX Audit Report Template (Markdown):


## DX Audit: {Platform Name}

### Methodology

- [ ] Installation friction
- [ ] First API call time
- [ ] Error message clarity

### Findings

| Metric | Score | Notes |
|--------|-------|-------|
| Install Time | 8/10 | npm install took 45s |

Project Scaffolding Script (Bash):

#!/bin/bash

# Scaffold a new platform-app project

mkdir -p $1/src/{components,utils,types}
cd $1
npm init -y
npm install typescript @types/node --save-dev
npx tsc --init
echo "Project $1 scaffolded successfully"

Interactive Demo Component (JavaScript):

// Drop-in demo for documentation sites
async function runHelloWorldDemo() {
  const client = new PlatformClient({ apiKey: 'demo-key' });
  try {
    const result = await client.query('Hello World');
    console.log('Success:', result);
    return { status: 'success', latency: result.timing };
  } catch (error) {
    console.error('Demo failed:', error);
    return { status: 'error', message: error.message };
  }
}

LSP/Index Engineer Deliverables

The specialized/lsp-index-engineer.md file provides a comprehensive TypeScript implementation for building language server protocol tooling.

Graph Daemon Server Skeleton (TypeScript):

// Core interfaces for graph construction
interface SymbolNode {
  id: string;
  name: string;
  kind: 'function' | 'class' | 'interface' | 'variable';
  location: { file: string; line: number; column: number };
  edges: Edge[];
}

interface Edge {
  target: string;
  type: 'calls' | 'implements' | 'extends' | 'imports';
}

// Client orchestration class
class GraphDaemon {
  private symbols: Map<string, SymbolNode> = new Map();
  
  async indexWorkspace(rootPath: string): Promise<void> {
    // Implementation: traverse files, parse AST, build graph
    console.log(`Indexing workspace: ${rootPath}`);
  }
  
  getSymbolGraph(symbolId: string): SymbolNode | undefined {
    return this.symbols.get(symbolId);
  }
}

Installation Verification (Bash):


# Verify LSP binaries are correctly installed

which typescript-language-server || npm install -g typescript-language-server
which graphd-lsp || echo "graphd-lsp not found, building from source..."
graphd-lsp --version

Frontend Developer Deliverables

The engineering/engineering-frontend-developer.md file contains production-ready React components and project templates.

Virtualized Data Table (TSX):

import { useVirtualizer } from '@tanstack/react-virtual';
import { memo, useRef } from 'react';

interface DataRow {
  id: string;
  name: string;
  status: 'active' | 'inactive';
  lastUpdated: Date;
}

export const VirtualizedDataTable = memo(function VirtualizedDataTable({
  data,
  onRowClick,
}: {
  data: DataRow[];
  onRowClick?: (row: DataRow) => void;
}) {
  const parentRef = useRef<HTMLDivElement>(null);
  
  const virtualizer = useVirtualizer({
    count: data.length,
    getScrollElement: () => parentRef.current,
    estimateSize: () => 48,
    overscan: 5,
  });

  return (
    <div ref={parentRef} className="h-full overflow-auto" role="table" aria-label="Data table">
      <div style={{ height: `${virtualizer.getTotalSize()}px`, width: '100%', position: 'relative' }}>
        {virtualizer.getVirtualItems().map((virtualRow) => {
          const row = data[virtualRow.index];
          return (
            <div
              key={row.id}
              style={{
                position: 'absolute',
                top: 0,
                left: 0,
                width: '100%',
                height: `${virtualRow.size}px`,
                transform: `translateY(${virtualRow.start}px)`,
              }}
              className="border-b border-gray-200 hover:bg-gray-50 cursor-pointer"
              onClick={() => onRowClick?.(row)}
              role="row"
              aria-rowindex={virtualRow.index + 1}
            >
              <div className="flex items-center px-4 h-full">
                <span className="font-medium">{row.name}</span>
                <span className={`ml-2 px-2 py-1 rounded text-xs ${row.status === 'active' ? 'bg-green-100 text-green-800' : 'bg-gray-100 text-gray-800'}`}>
                  {row.status}
                </span>
              </div>
            </div>
          );
        })}
      </div>
    </div>
  );
});

Project Deliverable Template (Markdown):


# Frontend Implementation Deliverable

## 1. Component Architecture

- **Virtualization Strategy**: @tanstack/react-virtual for 10k+ rows
- **State Management**: React Query for server state, Zustand for UI state
- **Accessibility**: WCAG 2.1 AA compliance, keyboard navigation

## 2. Performance Metrics

- First Contentful Paint: < 1.2s
- Time to Interactive: < 2.5s
- Bundle size: < 150KB (gzipped)

## 3. Testing Coverage

- Unit tests: Jest + React Testing Library (80%+ coverage)
- E2E: Playwright critical path tests

Cultural Intelligence Strategist Deliverables

The specialized/specialized-cultural-intelligence-strategist.md file includes a TypeScript utility for auditing UI patterns.

Exclusion Audit Function (TypeScript):

interface UIComponent {
  name: string;
  icon?: string;
  colorScheme?: string;
  textContent: Record<string, string>; // locale -> text
}

interface AuditResult {
  component: string;
  issues: string[];
  severity: 'low' | 'medium' | 'high';
  recommendations: string[];
}

/**
 * Audits a workflow for culturally insensitive patterns
 * Flags: naming conventions, color semantics, iconography
 */
function auditWorkflowForExclusion(
  components: UIComponent[],
  targetLocales: string[] = ['en-US', 'zh-CN', 'ar-SA', 'es-MX']
): AuditResult[] {
  const results: AuditResult[] = [];
  
  for (const component of components) {
    const issues: string[] = [];
    const recommendations: string[] = [];
    
    // Check color semantics (e.g., red = danger in West, luck in East)
    if (component.colorScheme?.includes('red')) {
      issues.push('Color "red" has conflicting cultural associations');
      recommendations.push('Allow color theme customization per locale');
    }
    
    // Check iconography
    if (component.icon && ['hand', 'thumbs-up'].includes(component.icon)) {
      issues.push(`Icon "${component.icon}" may be offensive in some cultures`);
      recommendations.push('Use culturally neutral icons or locale-specific variants');
    }
    
    // Check text content completeness
    const missingLocales = targetLocales.filter(loc => !component.textContent[loc]);
    if (missingLocales.length > 0) {
      issues.push(`Missing translations for: ${missingLocales.join(', ')}`);
      recommendations.push('Implement i18n fallback chain');
    }
    
    if (issues.length > 0) {
      results.push({
        component: component.name,
        issues,
        severity: issues.length > 2 ? 'high' : 'medium',
        recommendations
      });
    }
  }
  
  return results;
}

Testing and Support Agents

Several agents in the testing and support categories provide language-specific testing harnesses.

Workflow Optimizer (Python):

#!/usr/bin/env python3
"""
Workflow Optimization Simulator
Placeholder for custom logic to analyze and optimize CI/CD workflows
"""

import json
import sys
from typing import Dict, List, Any
from dataclasses import dataclass

@dataclass
class WorkflowStep:
    name: str
    duration: float  # seconds

    dependencies: List[str]
    parallelizable: bool = False

class WorkflowOptimizer:
    def __init__(self, workflow_data: Dict[str, Any]):
        self.steps = [WorkflowStep(**step) for step in workflow_data.get('steps', [])]
    
    def identify_bottlenecks(self) -> List[WorkflowStep]:
        """Find steps that block the critical path"""
        sorted_steps = sorted(self.steps, key=lambda x: x.duration, reverse=True)
        return [step for step in sorted_steps if not step.parallelizable][:3]
    
    def suggest_optimizations(self) -> Dict[str, Any]:
        """Generate optimization recommendations"""
        bottlenecks = self.identify_bottlenecks()
        return {
            "bottlenecks": [{"step": b.name, "duration": b.duration} for b in bottlenecks],
            "recommendations": [
                f"Parallelize {b.name}" for b in bottlenecks if b.parallelizable is False
            ],
            "estimated_time_saved": sum(b.duration * 0.3 for b in bottlenecks)
        }

if __name__ == "__main__":
    # Example usage with sample data

    sample_workflow = {
        "steps": [
            {"name": "install_deps", "duration": 120, "dependencies": [], "parallelizable": False},
            {"name": "lint", "duration": 45, "dependencies": ["install_deps"], "parallelizable": True},
            {"name": "test", "duration": 300, "dependencies": ["install_deps"], "parallelizable": True},
            {"name": "build", "duration": 180, "dependencies": ["lint", "test"], "parallelizable": False}
        ]
    }
    
    optimizer = WorkflowOptimizer(sample_workflow)
    results = optimizer.suggest_optimizations()
    print(json.dumps(results, indent=2))

API Tester (JavaScript):

// Example HTTP request using fetch to test API endpoints
const API_BASE_URL = process.env.API_BASE_URL || 'https://api.example.com/v1';
const API_KEY = process.env.API_KEY || 'test-api-key';

async function testApiEndpoint(endpoint, method = 'GET', body = null) {
  const url = `${API_BASE_URL}${endpoint}`;
  const options = {
    method,
    headers: {
      'Authorization': `Bearer ${API_KEY}`,
      'Content-Type': 'application/json',
      'Accept': 'application/json'
    }
  };
  
  if (body && (method === 'POST' || method === 'PUT')) {
    options.body = JSON.stringify(body);
  }
  
  console.log(`Testing ${method} ${endpoint}...`);
  const startTime = Date.now();
  
  try {
    const response = await fetch(url, options);
    const duration = Date.now() - startTime;
    const data = await response.json();
    
    console.log(`✓ Status: ${response.status} (${duration}ms)`);
    console.log('Response:', JSON.stringify(data, null, 2));
    
    return {
      success: response.ok,
      status: response.status,
      duration,
      data
    };
  } catch (error) {
    console.error(`✗ Request failed: ${error.message}`);
    return {
      success: false,
      error: error.message
    };
  }
}

// Example usage
(async () => {
  // Test GET endpoint
  await testApiEndpoint('/users');
  
  // Test POST endpoint
  await testApiEndpoint('/users', 'POST', {
    name: 'Test User',
    email: 'test@example.com'
  });
})();

Analytics Reporter (SQL):

-- Aggregate usage metrics from analytics table
WITH daily_metrics AS (
  SELECT 
    DATE_TRUNC('day', event_timestamp) as day,
    event_type,
    COUNT(*) as event_count,
    COUNT(DISTINCT user_id) as unique_users,
    AVG(session_duration_seconds) as avg_session_duration
  FROM analytics_events
  WHERE event_timestamp >= CURRENT_DATE - INTERVAL '30 days'
  GROUP BY 1, 2
),
support_tickets AS (
  SELECT 
    DATE_TRUNC('day', created_at) as day,
    COUNT(*) as ticket_count,
    AVG(resolution_time_hours) as avg_resolution_time
  FROM support_tickets
  WHERE created_at >= CURRENT_DATE - INTERVAL '30 days'
  GROUP BY 1
)
SELECT 
  d.day,
  d.event_type,
  d.event_count,
  d.unique_users,
  ROUND(d.avg_session_duration, 2) as avg_session_duration,
  COALESCE(s.ticket_count, 0) as support_tickets,
  ROUND(s.avg_resolution_time, 2) as avg_resolution_hours
FROM daily_metrics d
LEFT JOIN support_tickets s ON d.day = s.day
ORDER BY d.day DESC, d.event_count DESC;

Security and Design Agents

Security Engineer (YAML):


# CI Pipeline Security Gate Configuration

# Place this in .github/workflows/security-gate.yml

name: Security Compliance Gate

on:
  pull_request:
    branches: [main, develop]
  push:
    branches: [main]

jobs:
  security-scan:
    runs-on: ubuntu-latest
    steps:
      - uses: actions/checkout@v4
      
      - name: Run dependency audit
        run: |
          npm audit --audit-level=moderate
          if [ $? -ne 0 ]; then
            echo "::error::Security audit failed"
            exit 1
          fi
      
      - name: Check for secrets
        uses: trufflesecurity/trufflehog@main
        with:
          path: ./
          base: ${{ github.event.repository.default_branch }}
          head: HEAD
          extra_args: --debug --only-verified
      
      - name: SAST Analysis
        run: |
          echo "Running static analysis..."
          # Insert SAST tool commands here

          echo "Security gate passed"

UX Architect (Markdown):


# UX Research Plan: [Project Name]

## Research Objectives

1. Identify pain points in the current user onboarding flow
2. Validate proposed navigation structure with target users
3. Measure comprehension of new feature terminology

## Methodology

### User Interviews (n=8)

- **Duration**: 45 minutes per session
- **Participants**: Mix of power users and new sign-ups
- **Key Questions**:
  - "Walk me through how you would accomplish [task]"
  - "What do these terms mean to you: [feature names]"

### Usability Testing (n=12)

- **Tasks**: 
  1. Complete account setup
  2. Locate advanced settings
  3. Export data to CSV
- **Metrics**:
  - Task success rate
  - Time on task
  - Error rate
  - System Usability Scale (SUS) score

## Success Criteria

- **Must have**: 80% task completion rate for critical flows
- **Should have**: SUS score > 75
- **Nice to have**: < 2 minutes average time for simple tasks

## Deliverables

1. Research findings report (markdown)
2. Prioritized recommendation list
3. Updated wireframes based on findings
4. Presentation deck for stakeholders

Key Source Files and Repository Structure

The agent technical deliverables are located in specific directories within the msitarzewski/agency-agents repository. Each file follows the pattern of placing fenced code blocks immediately after the technical deliverables header.

Critical files containing reference implementations:

specialized/specialized-developer-advocate.md – Contains markdown documentation templates, Bash scaffolding scripts, and JavaScript demo implementations
specialized/lsp-index-engineer.md – Houses the TypeScript graph daemon skeleton and LSP installation verification scripts
engineering/engineering-frontend-developer.md – Includes the TSX virtualized table component and project deliverable templates
specialized/specialized-cultural-intelligence-strategist.md – Provides the auditWorkflowForExclusion TypeScript function for cultural sensitivity auditing
testing/testing-workflow-optimizer.md – Python workflow optimization skeleton
testing/testing-api-tester.md – JavaScript fetch-based API testing harness
support/support-analytics-reporter.md – SQL analytics aggregation queries
engineering/engineering-security-engineer.md – YAML CI pipeline security configurations
design/design-ux-architect.md – Markdown UX research plan templates

All files are accessible via the GitHub URL pattern: https://github.com/msitarzewski/agency-agents/blob/main/<path>.

Summary

Agent technical deliverables contain concrete, copy-pasteable code examples in multiple languages including TypeScript, JavaScript, Python, SQL, Bash, and Markdown.
Reference implementations like the auditWorkflowForExclusion function and the graph daemon skeleton demonstrate exact coding patterns agents should produce.
Automation templates such as the Bash scaffolding script and YAML security gates allow immediate integration into CI/CD pipelines.
Testing harnesses including Python workflow optimizers and JavaScript API testers validate that agent outputs meet functional requirements.
All examples reside in specific file paths within the msitarzewski/agency-agents repository, immediately following the technical deliverables headers.

Frequently Asked Questions

What programming languages are used in agent technical deliverables?

The repository utilizes TypeScript for LSP tooling and React components, JavaScript for API testing and browser demos, Python for workflow optimization scripts, SQL for analytics reporting, Bash for CLI scaffolding and installation verification, YAML for CI/CD security configurations, and Markdown for documentation templates and research plans. The language selection matches each agent's specific domain expertise.

How do the code examples help developers using these agents?

The code examples serve as executable specifications that eliminate ambiguity about expected agent outputs. Developers can copy the TypeScript interfaces from the LSP engineer deliverables directly into their codebase, run the Bash scripts to verify environment setup, or execute the SQL queries to validate analytics implementations. This approach bridges the gap between agent instructions and production code.

Where are the technical deliverables located in the repository?

Each agent's technical deliverables appear in markdown files organized by functional domain. Specialized agents reside in /specialized/, engineering roles in /engineering/, testing roles in /testing/, support roles in /support/, marketing in /marketing/, and design in /design/. Within each file, the code examples appear immediately after the "## 📋 Your Technical Deliverables" header, making them easy to parse programmatically.

Can these code examples be used in production environments?

Many snippets are production-ready templates, such as the virtualized React data table in engineering-frontend-developer.md or the SQL analytics queries in support-analytics-reporter.md. However, some examples like the Python workflow optimizer in testing-workflow-optimizer.md are explicitly marked as skeletons requiring custom logic implementation. Review each snippet's comments and context to determine if additional modification is required before deployment.

Have a question about this repo?

These articles cover the highlights, but your codebase questions are specific. Give your agent direct access to the source. Share this with your agent to get started:

Share the following with your agent to get started:

curl -s "https://instagit.com/install.md"

Add to your MCP client configuration:

{
  "mcpServers": {
    "instagit": {
      "command": "npx",
      "args": ["-y", "instagit@latest"]
    }
  }
}

Ask your agent:

"Use Instagit MCP to understand how msitarzewski/agency-agents works."

Works with

Claude Codex Cursor VS Code OpenClaw Any MCP Client

Maintain an open-source project? Get it listed too →