Jake Love
45.52° N, 122.68° W · Portland, OR

JakeLove

Software Architect & Forward-Deployed Engineer

I build the systems between design and production software — enterprise design systems, developer platforms, and the agentic infrastructure behind AI-assisted engineering.

View engineering workResume
20+
yrs building software
10+
yrs enterprise design systems
4
disciplines, one practice
jake@pdx — zsh — 72×10interactive

What I do

four disciplines, one practice
01

Software Architecture

Production systems, APIs, component architecture, platform engineering.

02

Enterprise Design Systems

Components, tokens, multi-brand architecture, Figma, design-to-code.

03

Forward-Deployed Engineering

Embedded customer engineering inside real enterprise constraints.

04

AI & Agentic Engineering

MCP, agent context, instructions, skills, orchestration, design-to-code.

Engineering highlights

sanitized · no customer detail
Case 01 · Design system architecture

Enterprise multi-brand design system

Architected a production integration layer connecting Figma Variables, generated design-token packages, React/Chakra themes, component APIs, staging environments, and enterprise release workflows — so multiple brands share one component surface instead of forking it.

Constraint
Multiple brands, one component API surface, no forks.
My role
Architecture, token pipeline, packaging, CI/CD, release.
Architecture
Design data → transforms → themes → versioned packages.
Outcome
Brand changes ship as releases, not rewrites.
  • TypeScript
  • React
  • Chakra
  • Style Dictionary
  • Figma Variables
  • CI/CD
Token pipeline01 / 04
Design decisions live as Figma Variables — one source of design data, owned by design, readable by machines.
Case 02 · AI & agentic engineering

Agent-ready enterprise design system

Component and token metadata exposed through MCP, paired with agent instructions, prompts, and skills, so generated UI uses the real system instead of approximating it. The lever is architecture and context quality, not prompt cleverness.

Constraint
Agents invent components the system already has.
My role
Context architecture, MCP surface, instruction design.
Architecture
Structured metadata + skills + tools over one protocol.
Outcome
More grounded design-to-code workflows using real system context.
  • MCP
  • Agent context
  • Skills
  • Design tokens
  • Node.js
MCP resource · component.meta.json
"name": "Button","tokens": ["color.action", …],"variants": ["solid","ghost","link"],"a11y": { "role": "button" },"usage": "one primary per view"

Agents get the real variant list, so they stop inventing a fifth one.

Case 03 · Forward-deployed engineering

Engineering inside regulated enterprise infrastructure

Embedded in a customer-controlled environment — their source control, gateway, identity provider, and deployment pipeline. The work was diagnosis, architecture, and the minimum necessary integration, done alongside their security and platform teams.

Constraint
No outbound access, customer-owned everything.
My role
Integration architecture, hands-on implementation.
Approach
Smallest surface that satisfies their controls.
Outcome
Shipped inside their constraints, not around them.
  • API gateway
  • Identity / SSO
  • CI/CD
  • Git
  • Node.js
Integration surface01 / 04
Their source control, their review process. I worked inside it rather than asking for an exception.
Case 04 · Field → product

From field problem to product capability

The same integration constraint kept surfacing across customer environments. Rather than working around it again, I specified it, built the fix into the platform myself, and brought the field evidence to Product and Engineering so it shipped as a supported capability.

Signal
The same workaround recurring across deployments.
My role
Diagnosis, spec, implementation, release.
Argument
Field engineering is a product input, not support.
Outcome
A recurring field workaround became a product capability I built.
  • Solutions Architecture
  • REST / GraphQL
  • Platform engineering
  • Implementation
Feedback loop01 / 04
The work starts in a real deployment, with a real constraint nobody planned for.

How I got here

one continuous engineering practice
  1. 2006–2014IPNS → StackHouse → Entercom
    Web engineering foundationsEight years building and shipping the whole stack of a site — design, front end, CMS, and the hosting under it.
  2. 2014–2016Phase2
    Enterprise engineering & technical leadershipAgency-scale implementations for national brands — the same client-facing engineering, at a size that demanded process.
  3. 2018–2020Basalt
    Component-driven engineeringDesign systems as engineering work: component APIs, tooling, and the path from component to production app.
  4. 2020–2023Knapsack
    Engineering → Solutions ArchitectureThe same engineering work, now pointed at customers: discovery, architecture, integration, enablement.
  5. 2024–2026Knapsack
    Forward-Deployed Architecture & EngineeringEmbedded inside enterprise environments — their repos, their pipelines, their constraints — writing production code.
  6. now2026 →
    Design systems + agentic engineeringArchitecture connecting design data, component systems, and AI agents that produce real code.
Architecture and implementation are the same practice to me. I don't design systems from a distance. I don't add my initials until I know it's possible and bulletproof. Twenty years in, this is still the work I'd pick on purpose.

About

I've spent more than 20 years building for the web, and I've never been interested in staying inside one box. The work crosses software engineering, design, architecture, customer engineering, and now AI and agentic systems. The common thread is probably curiosity — I like complicated systems, understanding why they work, finding where they break, and figuring out how to make them better.

That curiosity doesn't stop at software. I'm fascinated by physics and cosmology, from quantum field theory and the Standard Model to black holes and the scale of the universe.

More recently I've become an indie game developer, building a couple of original games toward release. It's a new playground for software architecture, game systems, storytelling, art, music, and all the wonderfully strange problems that come with shipping something of your own. I'm also a lifelong gamer with a truly irresponsible backlog and a nearly complete record of filling every Pokédex — I'm working on forgiving myself for the newest ones.

Pixel-art handheld console showing a portrait of Jake Love on its screen — opens riftloom.io
Same curiosity, different terrainriftloom.io ↗

Elsewhere in my head

  • Physics & cosmologyQuantum fields to black holes.
  • Indie game devTwo originals, heading for release.
  • Portland, OregonTrees, rain, elevation.
  • Nearly every PokédexForgiving myself for the newest ones.

Selected organizations

Enterprise teams I’ve designed, built, and solved hard problems alongside — across Knapsack, Basalt, Phase2, and Entercom.

  • GSK
  • PNC
  • Columbia Sportswear
  • Edward Jones
  • Vistaprint
  • Shutterfly
  • Twitter
  • NBA
  • The Home Depot
  • Associated Press
  • U.S. Space Force
  • Sherwin-Williams
  • College Board
  • Southern California Edison
  • Blue Origin
  • T. Rowe Price
  • Adobe
  • Qualcomm
  • Johnson & Johnson

Twenty years, agency and platform side.

Open to senior / principal roles

Let's talk about the hard part.

jake@jakelove.meLinkedInGitHubResume