Gas City, Inc.
Julian & Chris—I built this dedicated technical brief rather than dropping a generic PDF into an ATS queue.
Julian, your perspective on agentic leverage immediately resonated with me:
“Nobody here cares whether a line was typed by you or by an agent — we care about building the processes and frameworks that get us as much leverage as possible while maintaining quality. We are factory operators.”
That philosophy is why I am reaching out directly to Gas City. Most teams view AI as conversational autocomplete or an interactive novelty—spinning cycles in single-threaded chat boxes, drifting out of context, and treating software like disposable prompt output. In contrast, I build software as durable industrial tools: engineered to withstand severe real-world operational loads, maintainable across long lifecycles, and architected with explicit failure boundaries.
In physical manufacturing, a true factory operator doesn't hand-whittle every fastener; they design repeatable jigs, configure precision tooling, and inspect tolerances against strict mechanical drawings. The software factory demands the identical mindset. Real engineering leverage comes from architecting durable work graphs where autonomous agents execute against deterministic specifications, while the human engineer serves as chief inspector, systems architect, and invariant enforcer.
Gas City's mission—elevating agents to industrial workers and establishing the beads team server as the foundational operating substrate—aligns completely with how I build. Below is the direct, line-by-line verification matrix demonstrating how my software factory governance, distributed state architectures, and high-consequence verification habits map directly to your founding team.
Remote Command Station & Field Readiness
Multi-Display 4K Command Workstation
Dedicated multi-display 4K workstation engineered for concurrent engineering tasks: one display locked to primary code editor and AST trees, one dedicated to multi-agent AI execution and test harnesses, and one dedicated to live browser runtime, database inspectors, and telemetry logs.
Mobile Starlink Satellite Field Terminal
Equipped with an active mobile Starlink satellite field terminal providing instant high-bandwidth internet anywhere on the road, in remote shops, or trackside. When an urgent production issue strikes or immediate response is required (“if we need something right now”), I am online with low latency and zero excuses.
Proven Solo Driver & Force Multiplier
Zero hand-holding required. I do not wait around for someone to write tickets or unblock minor hurdles. Give me a high-level product objective and constraints, and I break it down into data schemas, API contracts, UI workflows, and deployable milestones—delivering completed features autonomously.
Not Scared to Speak Up & Challenge Assumptions
I do not nod along when a proposed requirement creates unmaintainable complexity, security holes, or brittle edge cases. I speak up respectfully, present concrete failure modes, and propose simpler, more durable architectures that protect the product roadmap from compounding technical debt.
Full Job Spec Alignment (5 Pillars)
“We are factory operators... building processes and frameworks that get as much leverage as possible while maintaining quality.”
Gas City needs software factory operators who design deterministic workflows, unblock agents, and maintain quality under maximum leverage.
Enforces rigorous task queue governance across autonomous agent workflows. Decomposes high-level directives into isolated work packages bounded by explicit state contracts, strict schema boundaries, and binary acceptance criteria in a structured queue (TASK_QUEUE.md). Specialized subagents operate in sandboxed contexts, while automated compilation governors (npx tsc --noEmit), AST lint inspections, and git diff audits catch regressions, synthetic hallucinations, and breaking changes before any code merges into production.
Deterministic work graphs, state-bounded task queues (TASK_QUEUE.md), AST & compiler-first gatekeepers, sandboxed agent contexts, and automated regression guards.
“A team system: one store, many agents and humans writing concurrently; project and identity boundaries; agent and API access; and a view that makes the state legible.”
Gas City's beads team server architecture demands robust multi-tenant concurrent writes, clear identity boundaries, and legible state views.
Architected concurrent multi-tenant data stores with strict transactional isolation across ShopOS and UpfittersOS, enabling shop technicians, fleet managers, and automated background daemons to mutate shared work orders simultaneously without race conditions. Enforced the Floating Dirty-State standard—instant isDirty form change tracking, viewport-docked action bars, and optimistic state synchronization that render complex multi-user workflow state legible and frictionless under high-load shop floor operations.
Normalized multi-tenant document stores, transactional mutation boundaries, RBAC identity fences, dynamic isDirty state tracking, and high-contrast legible operator views.
“You use agents with real leverage, and you can show your verification habits, not just your throughput... find the edge it missed, and say clearly what remains uncertain.”
Unchecked AI generation compounds errors; true software factory leverage requires relentless verification habits, AST inspection, and intellectual honesty.
Forged in safety-critical, zero-tolerance environments where unexamined assumptions carry lethal or mission-ending consequences. Commissioned the superconducting cyclotron for the Siemens Healthineers Varian ProBeam 360 Proton Therapy accelerator at OSF Saint Francis Hospital, where radiation beam targeting demands sub-millimeter clinical precision. Trackside at the Indianapolis 500 and across championship IndyCar seasons with Honda HRC, delivered real-time engine telemetry analysis under intense live race pressure. Translates directly into software verification: every agent diff is treated like an unverified pull request, subjected to AST inspections, strict static type checks (npx tsc --noEmit), and candid identification of edge-case uncertainties before deployment.
Multi-stage verification harnesses: static AST analysis, non-negotiable compiler passes (npx tsc --noEmit), automated invariant checks, and manual raw-code diff audits.
Static AST inspection, hallucinated dependency scans, non-existent SDK method detection before execution.
Data model schema invariants and boundary assertions before any mutation.
Tool execution sandboxes, compiler governors (strict daily quotas, rate limit backoffs).
Deterministic rollback playbooks, unit test assertions, and atomic state recovery.
Managing multi-agent state persistence across discrete sessions via deterministic task logs (TASK_QUEUE.md), preventing context degradation.
“Comfortable designing and debugging systems where state, concurrency, and failure matter: transactions and migrations, idempotency, retries and fencing, reconciliation loops, and observability.”
Core backend operations require handling edge cases in distributed state, idempotency, race conditions, and real-time synchronization.
Architected 60Hz telemetry bridge daemons (PyIRSDK / WebSocket IPC) with microsecond reconciliations, hardware-in-the-loop ESP32-S3 actuators with PWM timers, and distributed state machines with deterministic timeout/recovery handlers across the GridPass telemetry network.
Normalized document schemas, secure token claims, atomic transactional writes, and low-latency IPC bridges connecting local hardware daemons to cloud backends.
Distributed State & SQL Graph Engine: While TypeScript and Firebase were selected for rapid solo SaaS velocity in ShopOS and GridPass, systems architecture principles translate directly to high-concurrency Go services, Dolt version-controlled SQL, and distributed graph reconciliation loops (idempotency, fencing, conflict-free state resolution).
“Enough architectural experience to know what the stack should look like — and enough product taste to make a control plane feel obvious instead of merely complete.”
A developer control plane must be intuitive, frictionless, and clear under high cognitive load.
Engineered the Daylight Design System: high-contrast, space-efficient UI built for grease-covered shop hands and trackside paddock tablets. Strict 44px+ touch targets, zero mobile horizontal side-scrollers (filterable dropdown standard), and viewport-docked floating dirty-state save bars with automatic `isDirty` state tracking.
Tailwind CSS, mobile-first responsive viewports, accessible keyboard controls, animated skeleton states, and optimistic UI transitions.
Asynchronous Communication & Written Rigor
In a distributed, remote engineering team, written clarity is an engineering deliverable. I operate with high-signal, asynchronous communication that minimizes meetings while ensuring total visibility into decisions and trade-offs:
Every pull request includes explicit context, architecture trade-offs, potential failure modes, manual verification steps, and automated test coverage—enabling teammates to review efficiently without back-and-forth guessing.
When a data model limitation, rate limit, or security boundary poses risk to a timeline, it is surfaced immediately in writing with concrete alternative solutions—never swept under the rug until sprint deadline.
Concise daily debriefs answering three questions: what shipped to production, what is currently under execution, and what edge cases or dependencies require architectural alignment.
Candidate Dossier & Primary Downloads
Connect Directly with PJ Losey
“Available for a 15-minute introductory technical alignment call.”