AI-DNA Software Engineering Superbuilder

Description

The way most companies build community engagement and social media management software ages in a predictable way: roadmaps stretch into quarters, large teams ship what should take days, and the moment AI capability jumps, the org has no way to absorb it — because it was never built around AI in the first place. Despite the explosion of what coding agents can now do, the average team still treats AI as a helper bolted onto a human-paced process, and ships at that pace.

We tore that model apart. We're reinventing how community engagement and social media management get built — faster than ever before, with AI in our DNA, not bolted on — and the engineers who matter most aren't the ones typing fastest. They're the ones removing every bottleneck that stops AI from owning the end-to-end workflow. This role exists to build and continuously sharpen that system: the tools, context, and guardrails that let agents do whole units of work autonomously, so a lean team plus its agents delivers at the throughput and quality of a squad many times its size. You'll spend more of your time building the leverage than driving any single task — because that leverage compounds, and it's shared, so the whole team gets sharper every cycle. And you'll do it in a tight loop with product leadership: close enough to the vision that an idea raised on a customer call can be built before the call ends, or fully reflected by the next conversation.

We're a large enterprise organization with big customers, but we move like a startup — cycles measured in weeks, not months or quarters, let alone years. The quality bar is high for a reason: our customers are Fortune 100 brands, and when our software breaks, it's their brand reputation on the line. Throughput alone is worthless here — a fast engineer who ships regressions and brittle features is a net negative. We need enterprise scale and standards and startup speed.

What You Will Be Doing

• Build and continuously sharpen the system that lets AI own the work — the tools, skills, context, rules, and self-verifying harnesses agents need to run whole end-to-end workflows, so each class of work needs less human intervention over time. This is the heart of the role.
• Direct and improve a fleet of agents: delegate units of work in parallel, quality-check what comes back, and when an agent falls short, fix the underlying capability rather than just the output.
• Ship enterprise-grade, AI-powered features in a tight closed loop with product leadership — from reviewed plan and spec, through agent execution, to merged production releases. Fast enough that product and customer feedback can be implemented within the day.
• Multiply the whole team, durably: share your fixes back as reusable rules, context, and skills — so everyone's ceiling rises, not just yours.
• Lead a senior team of engineers — scoping work, reviewing approaches and PRs against the system model, and holding the quality bar before anything merges.

What You Will NOT Be Doing

• Writing code by hand, or sitting in 1:1 loops with an AI assistant. AI does the work; you build the system that lets it, and you own the result.
• Waiting for a detailed spec. You're handed a goal and trusted to figure out the right solution and ship it polished — product taste is part of the job.
• Doing the same task twice. If something was hard for an agent this week, you make it easy for next time and share the fix — you don't grind through it again.
• Settling on one tool. You operate at the frontier, daily, and you're always testing what's next so the team is never caught flat-footed when a better tool or model ships.
• Waiting for work, or being managed. You're mission-driven and proactive — you surface risks early, handle the unglamorous tasks without being asked, and treat blockers as challenges to overcome, not problems to escalate.
• Treating "merged" or "demo working" as "done." A feature is delivered when it's in a release a Fortune 100 customer can rely on, at enterprise quality.

Requirements

• AI-DNA — it's how you operate, not a tool you reach for. You don't write code by hand or sit in 1:1 loops with an assistant. Your default is to get out of the AI's way: build the context, tools, and guardrails that let agents own work end-to-end, then direct and verify.
• Strong product taste. You see a problem and figure out a good way to solve it without a detailed spec — a thinker and proposer, not just an implementer. Your output is polished and user-considered, with few bugs, so product leadership can hand you a goal and trust what comes back.
• Bottleneck-removal as your default. You spend more time building what agents need to work autonomously — skills, rules, context, harnesses, evals — than hand-driving tasks, and you operate closed-loop and in parallel, not 1:1. Tokens and tools are never the constraint here — your leverage through them is. Bluntly: if you're not efficiently spending your salary in tokens — turning a large budget into shipped, high-quality enterprise software and durable agent capability — you're not operating at the level this role demands.
• Frontier tool fluency, deep and broad. You command today's best agentic coding tools at a power-user level and manage fleets of agents — and you're never locked to one. You constantly test alternatives to spot the next best tool early. Mastery of one tool with no curiosity about the rest is a red flag; so is never having gone deep on any.
• Sharp, current model judgment. You can argue which frontier model to use when and why, what each is better at, what changed across recent releases, and what each provider just shipped. You start with the most capable model, then optimize for cost and latency.
• Ownership & proactiveness. Mission-driven, with a history of obsessing over the quality of your work, and no babysitting required — even on the boring tasks. You move work forward, surface risk early, and overcome blockers rather than escalate them.
• 5+ years of full-stack software engineering, primarily on web-based systems — genuine front-end and back-end depth, by a senior engineer who's already had a strong IC career and stepped up as a tech lead.
• Production AI/LLM integration — you've shipped real applications using LLMs via APIs, prompt engineering, agents, or automation.
• Cloud & delivery (one-stop-shop) — solid AWS and CI/CD experience, enough to own a product end-to-end as a one-person band: stand it up, ship it, and operate it without handing off the infrastructure.
• Model Context Protocol (MCP) — demonstrated understanding and prior application.
• Technical leadership & complex decisions — you've made hard architectural calls, led PR review, and directed senior and mid-level engineers; you set direction and hold the bar, not just produce.
• Enterprise-grade software experience — you've shipped production software at enterprise quality. Defensive coding, edge cases, validation, security, resilience, and automated evals are your default. You don't ship open-loop AI systems.

Nice to Have

• Prior experience building on enterprise community, social messaging, or customer-engagement platforms.
• Published writing, talks, or open-source contributions in AI-assisted engineering, agentic systems, or full-stack/LLM product work.
• Experience designing multi-agent or orchestrator/sub-agent workflows (parallel execution, worktrees, file-based agent communication).
• A track record of building reusable internal tooling — shared skills, rules, eval frameworks — that measurably raised a whole team's output.

What You Will Learn

You'll operate at the frontier of AI-native engineering — a live cross-section of full-stack product work, applied LLM systems, and agent orchestration at scale. You'll develop a rare depth in the thing that actually compounds: building the leverage that lets AI own more of the work, and sharing it so a whole team gets faster. The AI-native way of working here is already in production — you'll help define what it means to push the bottleneck back, again and again, making the whole system sharper over time rather than just keeping pace with it.

Working Conditions

Fully remote, async-first, global. No office. The team is lean and senior — you'll work in a tight loop with product leadership and direct both senior engineers and a fleet of agents, owning outcomes without a layer beneath you to lean on. Your week divides roughly across aligning on the vision and planning, building leverage and shipping, and review and team multiplication — with the balance shifting toward wherever the load demands. We default to async: status updates over status meetings, a shared written source of truth, deep work on your own schedule — paired with a fast feedback loop where customer and product input can be live the same day. Outcomes are defined explicitly and measured weekly:

• Software shipped — enterprise-grade features reaching releases Fortune 100 customers can rely on, at a throughput that replaces a team; no regressions, no reopened work.
• Bottlenecks removed — the human intervention each class of work needs trends down, not sideways, because you keep building leverage into the agents and sharing it.
• Standards enforced — what the team ships clears our quality gates (AI review against our guidelines, plus human review and evals) first-pass, consistently.
• Risks surfaced early — architectural and delivery risks flagged ahead of the customer-impact window, not after.

No token limits. No tooling limits. If the right answer is a better model, a different agent configuration, or a tool not yet in our stack, that conversation is always open. What we ask in return is simple: turn that leverage into enterprise-grade software a Fortune 100 brand can trust, and into a system that gets sharper every week.