Tech Lead and TypeScript expert agent for technical architecture, code reviews, and engineering best practices

Tom - Tech Lead & TypeScript Expert

Tom is a pre-configured autonomous agent specialized in technical leadership and TypeScript development, helping you with architecture design, code reviews, performance optimization, and engineering best practices.

Role & Expertise

Tech Lead with deep expertise in:

Software architecture and system design
TypeScript and modern JavaScript
Performance optimization and scalability
Code quality and best practices
API design and database schema
CI/CD and infrastructure
Technical mentorship
Security and reliability

Core Capabilities

Architecture Design - Design scalable, maintainable system architectures
Code Review - Review code for quality, performance, and best practices
TypeScript Expertise - Advanced type systems, generics, conditional types
Technical Assessment - Evaluate technical feasibility and effort estimation
Performance Analysis - Profile, benchmark, and optimize application performance
API Design - Design clean, type-safe, versioned APIs
Database Schema - Design efficient, normalized database schemas
DevOps - CI/CD pipelines, deployment strategies, monitoring

Quick Example

import { agent } from 'sdk.do'

const tom = await agent.create({
  name: 'tom',
  preset: 'tech-lead'
})

await tom.assign.task({
  type: 'review-architecture',
  data: {
    design: {...},
    requirements: [...],
    constraints: {...}
  }
})

Access Methods

SDK

Create and interact with Tom programmatically

const tom = await agent.create({ name: 'tom', preset: 'tech-lead' })

→ SDK Documentation

CLI

Deploy and manage Tom from command line

do agent create tom --preset tech-lead

→ CLI Documentation

API

REST endpoints for Tom integration

curl -X POST https://api.do/v1/agents -d '{"name":"tom","preset":"tech-lead"}'

→ API Documentation

MCP

Natural language interaction via AI assistants

Create tech lead agent named "tom"

→ MCP Documentation

Common Tasks

Code Review

await tom.assign.task({
  type: 'code-review',
  data: {
    pullRequest: 'https://github.com/org/repo/pull/123',
    focus: ['performance', 'type-safety', 'error-handling'],
    standards: 'airbnb',
  },
})

Architecture Design

await tom.assign.task({
  type: 'design-architecture',
  data: {
    requirements: ['Real-time collaboration', 'Support 10K concurrent users', 'Sub-100ms latency'],
    constraints: ['Cloudflare Workers', 'Durable Objects', '$500/mo budget'],
    preferences: ['TypeScript', 'type-safe', 'serverless'],
  },
})

Technical Feasibility

await tom.assign.task({
  type: 'assess-feasibility',
  data: {
    feature: 'Live video streaming',
    context: 'Web-based collaborative editor',
    team: { engineers: 3, timeline: '2 months' },
    requirements: ['1080p', 'low latency', 'browser-based'],
  },
})

Performance Optimization

await tom.assign.task({
  type: 'optimize-performance',
  data: {
    repo: 'https://github.com/org/repo',
    metrics: {
      pageLoad: '3.2s',
      ttfb: '800ms',
      fcp: '2.1s',
    },
    target: {
      pageLoad: '<1s',
      ttfb: '<200ms',
      fcp: '<0.8s',
    },
  },
})

API Design

await tom.assign.task({
  type: 'design-api',
  data: {
    domain: 'E-commerce platform',
    resources: ['products', 'orders', 'users', 'inventory'],
    requirements: ['RESTful', 'Type-safe', 'Versioned', 'Paginated', 'Real-time webhooks'],
  },
})

Database Schema

await tom.assign.task({
  type: 'design-schema',
  data: {
    domain: 'Multi-tenant SaaS',
    entities: ['organizations', 'users', 'projects', 'tasks'],
    requirements: ['Multi-tenant isolation', 'Soft deletes', 'Audit logs', 'Full-text search'],
    database: 'PostgreSQL',
  },
})

Integration with Other Agents

Tom collaborates seamlessly with other specialized agents:

// Collaborate with Priya (Product) on feasibility
await tom.collaborate.with('priya', {
  task: 'evaluate-feature-feasibility',
  feature: 'Real-time collaboration',
})

// Work with DevOps agent on deployment
await tom.collaborate.with('devops-agent', {
  task: 'design-ci-cd-pipeline',
  repo: 'https://github.com/org/repo',
})

// Pair with junior developer on code review
await tom.collaborate.with('junior-dev', {
  task: 'mentoring-code-review',
  pullRequest: 'https://github.com/org/repo/pull/456',
})

Customization

Customize Tom's behavior and preferences:

await tom.update({
  preferences: {
    codeStyle: 'airbnb',
    typeStrictness: 'strict',
    testCoverage: 'minimum-80',
    documentationStyle: 'tsdoc',
  },
  tools: ['typescript', 'vitest', 'eslint', 'prettier'],
  frameworks: ['hono', 'cloudflare-workers', 'durable-objects'],
  reviewFocus: ['type-safety', 'performance', 'security', 'maintainability'],
})

Example Workflows

Feature Implementation Review

const workflow = await workflow.create('feature-implementation', async ({ feature }) => {
  // Priya creates feature spec
  const spec = await agent('priya').assign.task({
    type: 'write-prd',
    data: { feature },
  })

  // Tom designs technical approach
  const design = await tom.assign.task({
    type: 'design-technical-approach',
    data: { spec },
  })

  // Tom reviews implementation
  const review = await tom.assign.task({
    type: 'code-review',
    data: { pullRequest, design },
  })

  return { spec, design, review }
})

Architecture Evolution

const workflow = await workflow.create('evolve-architecture', async ({ system }) => {
  // Tom analyzes current architecture
  const analysis = await tom.assign.task({
    type: 'analyze-architecture',
    data: { system, metrics: {...}, pain-points: [...] }
  })

  // Tom proposes improvements
  const proposal = await tom.assign.task({
    type: 'propose-architecture-improvements',
    data: { analysis }
  })

  // Priya evaluates business impact
  const impact = await agent('priya').assign.task({
    type: 'evaluate-business-impact',
    data: { proposal }
  })

  // Tom creates migration plan
  return await tom.assign.task({
    type: 'create-migration-plan',
    data: { proposal, impact }
  })
})

Performance Audit

const workflow = await workflow.create('performance-audit', async ({ application }) => {
  // Tom profiles application
  const profile = await tom.assign.task({
    type: 'profile-application',
    data: { application },
  })

  // Tom identifies bottlenecks
  const bottlenecks = await tom.assign.task({
    type: 'identify-bottlenecks',
    data: { profile },
  })

  // Tom creates optimization plan
  const plan = await tom.assign.task({
    type: 'create-optimization-plan',
    data: { bottlenecks, target: '<1s page load' },
  })

  // Tom implements optimizations
  return await tom.assign.task({
    type: 'implement-optimizations',
    data: { plan },
  })
})

TypeScript Expertise

Tom specializes in advanced TypeScript patterns:

Type-Safe API Design

await tom.assign.task({
  type: 'create-type-safe-api',
  data: {
    api: 'User management',
    features: ['End-to-end type safety', 'Zod runtime validation', 'OpenAPI schema generation', 'Client SDK auto-generation'],
  },
})

Advanced Type Patterns

await tom.assign.task({
  type: 'implement-advanced-types',
  data: {
    patterns: ['Branded types', 'Template literal types', 'Conditional types', 'Mapped types', 'Type predicates'],
    context: 'Domain modeling for e-commerce platform',
  },
})

Type System Optimization

await tom.assign.task({
  type: 'optimize-type-system',
  data: {
    issues: ['Slow type checking', 'Complex inference', 'Type errors unclear'],
    codebase: 'https://github.com/org/repo',
  },
})

Technical Standards

Tom enforces and promotes best practices:

Code Quality: ESLint, Prettier, TypeScript strict mode
Testing: >80% coverage, unit + integration + e2e tests
Documentation: TSDoc comments, README, API docs
Performance: Web Vitals, lighthouse scores, bundle size
Security: OWASP Top 10, dependency audits, secret scanning
Accessibility: WCAG 2.1 AA compliance
CI/CD: Automated testing, semantic versioning, changelog

agents primitive - Core agent functionality
Priya agent - Product Manager
functions primitive - Serverless functions
SDK agents reference - Complete SDK documentation
CLI agents commands - Command-line interface

Tom

On this page