Job Posting: Architectural Operator
Agent-Driven Software Engineering
About This Job Posting
We’re experimenting with our approach to hiring. We believe “mainstream” candidates won’t fit our needs, so we don’t want a “mainstream” process for sourcing and evaluating candidates.
After reading this job posting, if you’re interested in pursuing the opportunity, please send a message to start the process.
Location
San Francisco (in-office)
About the Role
We are not hiring a traditional software engineer.
We are hiring an Architectural Operator—someone who can design systems that produce software, not just write code.
With AI (“vibe coding”), code generation is no longer the constraint. The bottleneck is ensuring that what gets produced is semantically and syntactically correct, as well as reproducible and architecturally sound.
Your role is to:
Define systems that can rapidly generate high-quality software.
You will build and evolve agent-driven systems… that build and evolve agent-driven systems… that execute real business functions across the company.
The Pre-Interview Process (Mandatory)
To qualify for an interview, you must build and submit an agent system.
This is not theoretical. This is a real demonstration of how you work.
What You Must Build
Create an agent-based system that integrates across tools and produces useful outcomes.
Example use case:
Monitor Gmail and identify work-related emails
Convert emails into structured tasks
Use Asana as the system of record
Suggest or generate responses
Maintain state across systems and workflows
When we initiate the process after your expression of interest, we will provide you with a set of use cases from which you can select.
Critical Requirements (This Is What We Evaluate)
Your submission must demonstrate four things simultaneously:
1. Speed (Vibe Coding in Practice)
The system must be built using AI-assisted development (e.g., Cursor, similar tools).
You must make a video recording of your full build process (we envision this process as taking an hour or two, so you’re not making a three-day video).
We are evaluating:
How fast you move
How you interact with AI
How you structure prompts and iterations
This is not about perfection—it’s about velocity with control.
2. Architecture First
You must define a clear architectural structure upfront.
The system should follow consistent patterns (not ad hoc code).
Examples:
Event-driven flows
Clear orchestration (e.g., Step Functions or equivalent)
Defined data movement patterns
You should submit:
A short architecture overview: diagram or written, in the form of agent’s skill(s)
3. Runnable, Deployed System
The code must (we’re evaluating):
Be clean and understandable
Be runnable without friction
Be deployed in a real environment (cloud or equivalent)
We should be able to:
Run your system and see it work end-to-end without manual fixes.
4. Reproducibility + Iteration
This is critical.
You must show (again, on video) that your system can be modified and regenerated quickly.
After your initial build:
Make a meaningful change (e.g.):
Adjust functionality
Change data structures
Extend behavior
Then re-generate / evolve the system using AI
Here’s an example “change”, referring to the example use case from What You Must Build:
Want to monitor a different email account
Want to direct the resulting tasks to a different Asana account
We are evaluating:
How quickly you can adapt the system
Whether your architecture supports change
Whether the system breaks—or what used to work, still works
The goal is not just to build once—but to prove you can evolve it rapidly. When we review your submission, we’ll try to introduce changes for ourselves, to see how robust it is.
Evaluation & Outcome
Submissions are evaluated by an automated system and internal (human) review.
We assess:
Architectural quality
Speed and execution style
Reproducibility
Practical usefulness
If Selected:
You will be invited to interview
If your system is exceptional and usable, we will:
Extend an offer
Provide a signing bonus for your work
If you build something valuable, you will be compensated for it.
What You’ll Do When You Join the Team
1. Design Software Manufacturing Systems
Define architectural guardrails
Turn best practices into enforced patterns
Ensure reproducible outputs at scale
2. Architect Data-First Systems
Design around data integrity and flow
Build resilient, observable systems
Focus areas:
Graph databases
Event-driven architectures
Distributed pipelines
3. Build and Evolve Agents
Create agents for real business functions
Encode logic, workflows, and decision-making
Continuously improve output quality
4. Replace Work with Systems
Identify manual workflows
Replace them with agents
Reduce operational overhead
5. Operate at High Velocity
Use AI (“vibe coding”) as a core tool
Move fast without sacrificing structure
Eliminate fragile implementations
Our Technical Environment
AWS (Primary)
Lambda
Step Functions
EventBridge, SQS, SNS
DynamoDB
Serverless-First
Stateless, event-driven design
No long-running services unless necessary
Data Infrastructure
Graph databases (Neo4j or similar)
Data pipelines (batch + streaming)
Strong observability
Our Core Principles
Code is disposable. Architecture is permanent.
Reproducibility > Reusability
Speed without structure creates failure
If it can be done twice, systematize it
The best system is one you never need to fix
What Makes You a Fit
You:
Think in systems, not tasks
Prefer designing patterns over writing code repeatedly
Move fast and embrace AI as a core tool
Care deeply about correctness and structure
Want to eliminate work—not create more of it
Compensation Philosophy
We reward:
Fast, correct execution
Systems that don’t require rework
Outputs that eliminate future effort
The highest-value work is done once—and never revisited.
Why This Role Exists
We are building a new model of software engineering:
Business functions are performed by agents
Agents are generated by agents, not written by humans
Architecture—not code—is the core asset
If you can build systems that build systems, this role is for you. Please send a message to start the process.