Design Engineer: Infrastructure New York City

Meetkay; New York, Northern (NY, KY); Hybrid; USD 120,000 - 160,000; Full time

Job summary

YakLabs is building a desktop AI application and needs an engineer to own the design system foundations. You will implement a component library, define tokens, and enable runtime theming so teams and agents can ship UI quickly and consistently.

You will focus on frontend quality, API-style component design, and tooling that catches drift before it ships. In-person work in New York City is expected for product and design roles, with some engineering roles remote.

Qualifications

• Built or maintained a design system or component library in production that engineers rely on.
• Design in code with a trained eye for spacing, typography, color, and motion.
• Strong frontend engineering focus on React, CSS, accessibility, and performance.
• Think in APIs; design component props as robust interfaces.

Responsibilities

• Own the component library and design tokens; retire duplicates and migrate the app.
• Build the theming system as extendable tokens for UI surfaces.
• Create visual verification tooling: state catalogs, visual regression tests, accessibility checks.
• Develop prototyping tools so non-designers can explore ideas without rewrites.
• Translate design decisions into reusable assets used by people and agents.

Skills

Frontend engineering

React

CSS

Accessibility

Performance

Job description

YakLabs is building a desktop AI application that turns knowledge workers into AI power users, without docs, API keys, or knowing what to ask for. One surface for agentic AI work: proactive, personalized, progressively powerful. The gap between AI power users and everyone else isn’t talent, it’s setup. We close it.

The team: Alex Goddijn spent four years at Palantir, then founded an agent harness company that was acquired by Poolside AI. Seb Goddijn led internal AI at Ramp. We’re building Kay so that kind of leverage isn’t limited to companies with their own internal AI team.

We have funding. Product and design work in person in New York City, and some engineering roles are remote. Small team, high intensity, no passengers.

The job

Your goal is to let anyone at Kay build a feature that looks and feels like Kay, without waiting on a designer. Engineers, product managers, and the agents they work with all ship UI here, and more of the interface is assembled at runtime by agents and plugins. A design review for every change doesn’t scale to that. So you turn the product’s design decisions into infrastructure: themes, tokens, components, and prototyping tools that make the aligned choice the easy one, plus checks that catch drift before it ships. Our other design engineers own how specific surfaces look and feel. You own the foundation everyone builds on.

Problems you’ll work on

These are examples, not lanes. You will move between them, while taking real ownership of the ones that match your interests.

• Design input without a meeting: A product manager or engineer should be able to start a feature and land somewhere consistent with the rest of the product, without booking time with design. What does the system need to encode, in components, patterns, and written rules, for that to hold?
• Prototyping on the real system: A prototype built with throwaway styles looks convincing, then gets rebuilt from scratch and loses what made it good. How do you make prototyping fast enough that people want to use the real themes and components from the first sketch, so a good prototype is most of the way to production?
• A design system agents use correctly: Agents and plugins build new surfaces faster than people can review them. What components, APIs, and constraints let them produce UI that is accessible, on brand, and consistent by default, and what does the system do when they get it wrong?
• Every state, every theme, every size: A desktop app with user themes, dense and sparse layouts, and dozens of transient states. How do you make it cheap to see and verify all of them, so a machine catches a regression before a person does?
• One source of truth: The design system shows up in a reference site, the app, the marketing site, and prototypes. How do you keep design and code one thing instead of two things that drift apart?
• Theming people can own: People want the product to feel like theirs. How far can theming and customization go before they break legibility, contrast, or the product’s identity?

What you’ll do

• Own the component library and design tokens: build the primitives, retire the duplicates, and move the app onto them.
• Build the theming system: color, type, density, and motion as tokens that users and plugins can extend safely.
• Build visual verification tooling: state catalogs, screenshot and visual regression tests, and accessibility checks in CI.
• Build the prototyping tools, so anyone on the team can explore a new direction in the real system in minutes and promote it to production without a rewrite.
• Turn design decisions into things people and agents can use without asking: patterns, examples, and the rules and skills that teach agents to build with the system. Then measure whether they follow them.
• Watch where features drift from the rest of the product, and fix the cause in the system rather than the symptom in the feature.

Who you are

• You’ve built or maintained a design system or component library in production that other engineers relied on.
• You design in code, and you have a trained eye. Spacing, type, color, and motion bugs jump out at you.
• Strong frontend engineering: React, CSS, accessibility, and performance.
• You think in APIs. A component’s props are an interface that people and agents will misuse, and you design for that.
• You’d rather make the wrong thing impossible than write a guideline about it.
• You measure your work by what other people ship. A good week is one where the team built three aligned features you never had to look at.

Bonus

• You’ve built for desktop apps (the constraints are different from web).
• You’ve built prototyping tools that non-designers adopted.
• You’ve built visual regression or screenshot testing infrastructure.
• You’ve shipped PRs to open-source design system or agentic harness projects.

Who we look for

These apply to every role at YakLabs.

• First principles thinking. We’re building in a category that’s being defined in real time. Best practices don’t exist yet. You reason from the problem, not from what everyone else is doing.
• High agency and ownership. You don’t wait to be told what to do. You see what needs to happen, you go make it happen, and you own the outcome. At a team this size, there’s nobody to delegate to.
• Deep curiosity about AI tooling. Not just using ChatGPT or Copilot: you’re experimenting, writing your own tools, trying new agent frameworks the week they drop, forming opinions about what works and what doesn’t. The people building this product should be the most demanding users of the category.
• You build compounding leverage. In the era of building with agents, one person doesn’t just ship one person’s work, they build the systems that build the product. Every person is amplified, and with that amplification comes the responsibility to build things that compound: skills, automations, agent workflows that make the next thing faster. This is a new way of working, and you’re excited to develop the skillset it demands.

The deal

• Early team, meaningful equity.
• In person in New York City for product and design roles. Some engineering roles are remote, and each posting lists its location.
• You’ll shape the product, the culture, and the company. This is a founding-team role.

How we hire

YakLabs is an equal opportunity employer. We consider every application withoutregard to race, color, religion, sex, gender identity, sexual orientation,national origin, age, disability, veteran status, or any other protectedcharacteristic. If you need an accommodation at any point in the process, email [e-mail] and we will work it out with you. A person, not a machine,reads every application.