# Full-Stack Engineer Portfolio
# Theme: SRCL (terminal aesthetic)

meta:
  name: Jamie Chen
  title: Full-Stack Engineer
  location: San Francisco, CA
  timezone: UTC-8

contact:
  email: jamie@example.dev
  website: https://jamiechen.dev
  github: jamiechen
  linkedin: jamiechen
  twitter: jamiechendev

bio: |
  i build things fast and ship them faster.

  currently obsessed with multi-agent systems,
  edge computing, and making developer tools
  that don't suck.

about:
  short: Full-stack engineer building agent systems and edge computing tools
  long: |
    I've been writing code since I was 12, starting with terrible PHP scripts
    and gradually making my way to slightly less terrible TypeScript.

    I believe in boring technology, fast feedback loops, and shipping early.
    Most of my work focuses on developer tools and infrastructure—the unsexy
    stuff that makes everything else possible.

    When I'm not coding, I'm probably playing retro games or tinkering with
    mechanical keyboards.

settings:
  color_scheme: dark
  enable_hotkeys: true
  animate: subtle

layout:
  homepage_style: minimal
  project_layout: case-study
  show_experiments: true
  show_timeline: true

sections:
  experience:
    - company: Vercel
      role: Senior Software Engineer
      date:
        start: 2022-03
        end: present
      description: Edge runtime and developer experience team
      highlights:
        - Led development of edge middleware caching layer, reducing p99 latency by 40%
        - Built internal tooling used by 200+ engineers daily
        - Shipped features to 2M+ developers on the platform
        - Open-sourced three internal libraries with 5k+ GitHub stars combined

    - company: Stripe
      role: Software Engineer
      date:
        start: 2020-01
        end: 2022-02
      description: Payments infrastructure team
      highlights:
        - Designed and implemented idempotency system handling 50M+ requests/day
        - Reduced payment processing latency by 25% through query optimization
        - Mentored 4 junior engineers through onboarding and growth
        - On-call rotation lead for critical payment systems

    - company: Intercom
      role: Junior Software Engineer
      date:
        start: 2018-06
        end: 2019-12
      description: Messenger platform team
      highlights:
        - Built real-time typing indicators using WebSocket architecture
        - Contributed to migration from Rails monolith to microservices
        - Shipped A/B testing framework for messenger experiments

  # Simple projects (backwards compatible)
  projects:
    - name: Agent Orchestrator
      description: Multi-agent coding system with planning, execution, and review phases. Uses LLM routing for optimal model selection.
      url: https://github.com/jamiechen/agent-orchestrator
      tags: [TypeScript, AI, LangChain, Redis]
      featured: true

    - name: fastcache
      description: In-memory cache with automatic invalidation and cluster sync. 10x faster than Redis for hot paths.
      url: https://github.com/jamiechen/fastcache
      tags: [Go, Performance, Distributed Systems]
      featured: true

    - name: devfolio.page
      description: CLI tool that generates portfolio sites from YAML. Version control your resume.
      url: https://github.com/jamiechen/dev-page
      tags: [TypeScript, CLI, Static Site Generator]

    - name: edge-queue
      description: Durable message queue for edge environments. Works with Cloudflare Workers and Vercel Edge.
      url: https://github.com/jamiechen/edge-queue
      tags: [TypeScript, Edge Computing, Queues]

    - name: retro-arcade
      description: Collection of classic arcade games rebuilt in Rust. Playable in the terminal.
      url: https://github.com/jamiechen/retro-arcade
      tags: [Rust, Game Dev, CLI]

  skills:
    Languages: [TypeScript, Go, Rust, Python, SQL]
    Frameworks: [Next.js, React, Node.js, Express, Fastify]
    Infrastructure: [AWS, Vercel, Cloudflare, Docker, Kubernetes]
    Databases: [PostgreSQL, Redis, DynamoDB, Planetscale]
    Tools: [Git, Vim, tmux, Linear, Figma]

  writing:
    - title: "Building Multi-Agent Systems That Actually Work"
      url: https://jamiechen.dev/blog/multi-agent-systems
      date: 2024-11
      publication: Personal Blog

    - title: "Edge Computing Patterns for Real-Time Applications"
      url: https://vercel.com/blog/edge-patterns
      date: 2024-08
      publication: Vercel Blog

    - title: "Why I Switched from Redis to In-Memory Caching"
      url: https://jamiechen.dev/blog/redis-to-memory
      date: 2024-03
      publication: Personal Blog

    - title: "The Case for Boring Technology in 2024"
      url: https://jamiechen.dev/blog/boring-tech
      date: 2024-01
      publication: Personal Blog

  education:
    - institution: Stanford University
      degree: B.S. Computer Science
      date:
        start: 2014-09
        end: 2018-05
      description: Focus on distributed systems. Thesis on consensus algorithms.

# Rich projects (case studies with detailed content)
projects:
  - id: agent-orchestrator
    title: Agent Orchestrator
    subtitle: Multi-agent system for complex coding tasks
    featured: true
    thumbnail: /images/projects/agent-orchestrator-thumb.png
    hero: /images/projects/agent-orchestrator-hero.png
    meta:
      year: 2024
      role: Creator & Maintainer
      timeline: 6 months
      tech: [TypeScript, LangChain, Redis, PostgreSQL]
      links:
        github: https://github.com/jamiechen/agent-orchestrator
        demo: https://agent-demo.jamiechen.dev
    sections:
      - type: overview
        content: |
          Agent Orchestrator is a framework for building multi-agent coding systems.
          It handles the complexity of coordinating multiple AI agents—planning,
          execution, review—so you can focus on the actual problem.

          The key insight: most coding tasks benefit from specialization. A planning
          agent thinks differently than an execution agent. By separating concerns,
          we get better results than a single monolithic agent.

      - type: metrics
        data:
          - label: GitHub Stars
            value: "2.3k"
          - label: Weekly Downloads
            value: "15k"
          - label: Contributors
            value: "47"
          - label: Task Success Rate
            value: "89%"

      - type: code
        title: Basic Usage
        language: typescript
        code: |
          import { Orchestrator, PlanningAgent, ExecutionAgent } from 'agent-orchestrator';

          const orchestrator = new Orchestrator({
            agents: [
              new PlanningAgent({ model: 'gpt-4' }),
              new ExecutionAgent({ model: 'gemini-pro' }),
            ],
            routing: 'auto',
          });

          const result = await orchestrator.run({
            task: 'Refactor the authentication module to use JWT',
            context: { codebase: './src' },
          });

      - type: outcomes
        content: |
          ## Impact

          - Reduced complex refactoring time by 60% in internal testing
          - Adopted by 3 YC companies for their internal tooling
          - Featured in "This Week in AI" newsletter

          ## Lessons Learned

          Agent coordination is hard. The biggest challenge wasn't the AI—it was
          managing state and handling failures gracefully. Redis turned out to be
          essential for distributed agent state.

  - id: fastcache
    title: fastcache
    subtitle: Blazing fast in-memory cache for Go
    featured: true
    thumbnail: /images/projects/fastcache-thumb.png
    meta:
      year: 2023
      role: Creator
      timeline: 3 months
      tech: [Go, Assembly, Benchmarking]
      links:
        github: https://github.com/jamiechen/fastcache
    sections:
      - type: overview
        content: |
          Redis is great, but for hot paths where every microsecond counts,
          network latency kills you. fastcache is an in-memory cache that
          lives in your process, with automatic cluster synchronization.

      - type: metrics
        data:
          - label: vs Redis (p50)
            value: "10x faster"
          - label: Memory Overhead
            value: "< 5%"
          - label: Production Users
            value: "200+"

      - type: code
        title: Benchmark Results
        language: text
        code: |
          BenchmarkFastcacheGet-8     50000000    24.3 ns/op    0 B/op    0 allocs/op
          BenchmarkRedisGet-8          5000000   243.1 ns/op   48 B/op    2 allocs/op

          fastcache is 10x faster with zero allocations per operation.

# Experiments (smaller side projects)
experiments:
  - title: vim-copilot
    description: Copilot integration for Vim that doesn't suck. Async completions with zero lag.
    github: https://github.com/jamiechen/vim-copilot
    tags: [Vim, AI, Lua]

  - title: json-parser-rs
    description: Zero-copy JSON parser in Rust. Learning project that got out of hand.
    github: https://github.com/jamiechen/json-parser-rs
    tags: [Rust, Parser, Performance]

  - title: dotfiles
    description: My meticulously crafted development environment. Vim + tmux + zsh.
    github: https://github.com/jamiechen/dotfiles
    tags: [Config, Shell, Vim]

# Career timeline
timeline:
  - year: 2024
    title: Launched Agent Orchestrator
    description: Open-sourced the multi-agent framework after 6 months of development.

  - year: 2022
    title: Joined Vercel
    description: Started working on edge runtime and developer experience.

  - year: 2020
    title: Joined Stripe
    description: Moved to payments infrastructure, learned about scale.

  - year: 2018
    title: First Job at Intercom
    description: Started my career building real-time messaging features.

  - year: 2018
    title: Graduated Stanford
    description: B.S. Computer Science with focus on distributed systems.

theme: srcl
