AI-Native Software Engineer

About the role
Most engineering teams have added AI to their workflow. A few have rebuilt their workflow around it. We want to be in the second group, and we are hiring the person who will show us how.
This is not a role where you build LLM products. This is a role where you build our product with agents — and then turn the way you work into the way the whole engineering organization works.
You will work inside a real, high-traffic production codebase: the platform that 2,000+ brands use to engage customers across channels, processing 2.2 billion requests and delivering nearly 2 billion notifications every day. You will plan, implement, test, review, debug and ship features with coding agents doing most of the work, while you set the intent and own the outcome.
Then you will make it the standard. Not a playbook nobody reads — global agents, shared rules, guardrails that ship with them, and numbers on a dashboard that show whether any of it is working.
If your first reaction to a repetitive workflow is "this should be an agent," and your second is "and here is how we prove it helped," we should probably talk.
Why this role exists
We looked at how our engineers work today. Some of them use AI to finish a line of code faster. That is autocomplete, and it is not what we mean.
We mean the full loop: you scope a change, an agent reads the codebase and writes a plan, you correct the plan, the agent implements across many files, runs the tests, fixes what it broke, and opens a pull request. You review the output like a senior engineer reviews a junior — because that is exactly what it is.
Some people already work like this every day. That is table stakes for this role. What we actually need is the next step: someone who can take that way of working, make it a company standard, secure it, measure it, and keep improving it from the data.

What You Will Do

- Ship with agents. Claude Code first, plus Codex, Cursor, Copilot or whatever earns its place — your main tool across design, implementation, testing, debugging, refactoring, documentation and review. Real features, high traffic, the quality bar you would hold for hand-written code.

- Build the shared setup. Global agents, skills, context files, MCP (Model Context Protocol) integrations and prompt templates, with the guardrails that ship with them: architectural limits, forbidden patterns, folder boundaries, least privilege on agent credentials. Design the human-in-the-loop so people are pulled in only for the highest-risk architectural and security calls.

- Automate the repetitive. Agentic systems that use tools, hold state and run multi-step work — for our product and for our own workflows. Own the AI review pipeline and the test-coverage gate as products, tuned on our own escape history rather than a generic rule pack.

- Secure the AI surface. Threat-model AI-assisted development and its supply chain. Automated defences in CI (Continuous Integration) against prompt injection, jailbreak, tool-call abuse and data poisoning. No AI-invented auth or crypto, no unverified dependencies, no leaked secrets.

- Measure it and close the loop. Agent impact, vulnerability escape rate, review precision, test effectiveness, adoption — on a dashboard, not in anecdotes. Every production escape becomes a permanent guardrail, regression test or rule within one cycle.

- Make it the standard and teach it. Org-wide standard, tracked adoption, updated from the data — including the trade-off call when a guardrail costs velocity. Sessions, reviews of other people's AI-assisted pull requests, the playbook, the mentorship program. This is half the job, not a bonus.

- Call the tooling honestly. Test what is new, tell us what is worth adopting and what is noise, and work with product and business teams to find the workflows worth automating.

What You Will Need

Must have

- Daily production use of coding agents. Not a course, not a demo, not a side project. Something with users, where the agent did most of the writing and you owned the result.

- One project end to end with these tools — empty repo to live — that you can walk us through: what you delegated, what you kept, where it failed you, how you caught it.

- Proof it spread past you. A standard, rule set, shared agent, review pipeline or playbook that other engineers actually used, and a real answer on how adoption went.

- You have measured something. Accepted-code rate, rework, escape rate, review false positives, time saved — and what you changed because of it. "It felt faster" does not clear this bar.

- Agentic depth: tool and function calling, multi-step workflows, state, error recovery, human-in-the-loop.

- Security instinct around AI surfaces. Prompt injection, tool abuse, secret leakage, unverified dependencies — and something concrete you have done about at least one of them.

- Fundamentals and judgment. Clean code, testing, error handling, performance: agents make weak fundamentals more expensive, not less. And you know when the agent is wrong — speed is easy to fake, judgment is not.

- The ability to teach it. You can take how you work and make it someone else's habit.

Language is not a filter. Go and PHP/Laravel are preferred because that is what we run; Python, TypeScript or anything else is fine if the rest is there.

Nice to have

- 2+ years designing highly scalable, highly available systems, most of it in Go.

- LLM work: prompt engineering, agent SDKs, or orchestration frameworks such as Strands Agents, LangChain or LlamaIndex.

- Agentic patterns beyond the basics: RAG, MCP, agents, skills, hooks, plugins.

- Feeding SAST (Static Application Security Testing) and dependency findings back through an agent loop so it writes a real patch, not a suppression.

- Producing ADRs (Architecture Decision Record) with AI and defining measurable architectural fitness checks.

- Curiosity about how these systems actually work under the hood: benchmarking them, breaking them, improving them.

On seniority

We do not filter on years or titles, and we will read a strong three-year profile next to a strong ten-year one. But be clear about the bar: this role is scoped at the top level of our internal AI-Native Engineer matrix. We are looking for someone who has already built the standard, not someone who is ready to start following one.

What We Offer

- Enjoy a monthly meal allowance designed to enhance your daily routine

- Access comprehensive private health insurance

- Find your people with yoga classes, running and cycling clubs, and nutrition workshops

- Feed your curiosity with access to Spotify, LinkedIn Learning, Blinkist, MasterClass, Neoskola, and CloudGuru

- Level up with internal trainings covering AI fundamentals, coding, foreign languages, and a wide range of personal development skills

- Be part of a diverse team that’s as global as it gets — where every voice is heard and 50+ nationalities build together

- Become a Shareowner through our eligibility-based “ESOP” and own a piece of what you build

- Help build the team you want to work with and enjoy rewarding referral bonuses

- Opportunities to give back to your community through volunteering and purpose-driven social impact projects

- From global retreats to team-building activities, expect year-round events that turn into lifelong memories

We provide equal opportunity in a zero-discrimination workplace and not just welcome but also embrace everyone without regard to sex, race, color, nationality, religion, gender identity, sexual orientation, disability status, citizenship, or marital status.

Please follow Insider One on LinkedIn, Instagram, X, Facebook and Medium!