Full-Stack Engineer

Own products for years rather than weeks — build them properly, keep them alive, and make the agentic build method something a team can rely on.

Mainloop is a new engineering team inside an established international group. We are in Barcelona, we are being built from scratch this year, and we have the backing, the customers and the product portfolio of a company that has been around for decades. You get the interesting part of a new team without the part where you check whether payroll clears.

Two more things about where this comes from and where it goes. The group has been running a tech lab in Casablanca for more than eight years — Barcelona is its second, built to sit closer to the teams we build for, and AI-native from the first commit, because it starts from a blank page. And the plan does not stop at internal work: within about a year and a half we intend to externalise — external clients, our products sold on the market, products developed for it. The first eighteen months are deliberately spent building as much as possible for the group while the machine gets set up. You would arrive at the start of that curve, not after it.

What we build is the software that automates professional-services work — across roughly fifteen countries, for businesses that are drowning in process. We work in two halves. One half goes into a business, works out what actually happens there, and builds a prototype fast enough to prove it is worth having. The other half — this half — takes that prototype and turns it into something a company depends on. Most automation teams only have the first half, which is why most of them have a drawer full of demos and nothing in production.

We are hiring the engineers for the second half.

We are hiring at two levels, and we would rather say so than let you guess. There are four junior seats and one senior seat. The junior seats are open to people coming out of university and to young engineers generally — what we are looking for there is not a track record, it is appetite: you want to get very good very fast, and you have already been building with coding agents (Claude Code, Cursor, Codex or similar) because you found them interesting rather than because someone told you to. The senior seat is for someone who has owned production software for years and is ready to set the architecture others build inside. Apply to the same ad either way — tell us which one you think you are, and we will talk about it in the first conversation.

What the job actually is

Every product we own is run by two people: a Product Owner and you. The PO holds the relationship with the business, the needs and the roadmap. You hold the build, the architecture, the quality and the release. That is real ownership — your name on something people use, with the authority to decide how it is built.

And you will not be doing it on one thing forever. Our portfolio is deliberately varied: platforms used daily by consultants across roughly fifteen countries, agent-native products we are inventing as we go, and the internal tooling that makes the whole method work. New projects arrive continuously from the other half of the team. You will move between them, and the range is one of the best things about the job — you get depth on something you own and the variety of a team that starts something new every quarter.

In a typical year you will:

• Take over a product and make it yours. It arrives documented, hardened and ready — from a colleague who has moved on to the next thing. And you are not left to read 40,000 lines on your own: every repo ships the context files our agents read, we run code search and navigation across the whole estate, and you have Claude Code pointed at it. Getting oriented in an unfamiliar system is a skill you will get very good at here, and we give you the tools that make it a day rather than a month.
• Keep it moving. A product that stops evolving stops being used. You and your PO decide what is next and you ship it.
• Design more than you type. More on that below — it is the part of this job most different from your last one.
• Start something new. New products land regularly, and the person who owns them is whoever is ready for the next one.

You will get seriously good at building with AI agents

This is the part we would underline. We are an AI-native engineering team, genuinely — not a team that added a Copilot licence. Every engineer gets their own Claude Max subscription and a desktop orchestrator that runs several coding agents in parallel, each in its own branch. You will learn to drive that properly: how to get quality and speed out of it at the same time, where it fails, and how to sit down with a diff and work out whether it is actually right — which is a skill, and one worth taking your time over.

Which changes what the job feels like. Far less of your week is spent typing implementation. Far more is spent on the things that actually decide whether software is good: what should be built, how it should be shaped, where the hard edges are — and then dropping into the detail precisely where the detail matters. It is a more architectural, more strategic job than the same title was three years ago, and that is the direction the whole profession is moving. You will be ahead of it, not catching up.

Some specifics, so you know how we keep the quality up:

• Every merge is reviewed by an agent, in a find-fix-re-review loop that runs until clean. It means fast feedback and no waiting on a colleague to get to your PR.
• Every build ships tests, and the gate is 100% pass. Unit, smoke against the real running thing, and Playwright end-to-end. This one we are strict about — it is what lets a small team ship quickly without breaking things.
• Anything AI-powered ships with evals — a scored set of inputs, not "it looked right when I tried it". Model choice goes through a gateway, so nobody is stranded on a deprecated model.
• Judgement is what we value. Agents make writing code cheap, which makes judging code the valuable thing. Seniority here is measured in the quality of your decisions, not your output volume.

If you have been using agents seriously and have opinions about where they break, we want to hear them. If you are curious but not yet deep in it, that is fine too — teaching this well is something we intend to be known for.

"If agents write the code, what am I for?"

It is the fair question to ask of an ad like this one, so here is our answer plainly: the agents are the fastest part of the team and the least trustworthy one, and that is not a problem we expect to go away. Everything that makes software actually good still runs through a person.

What stays yours, permanently:

• Turning a need into a specification that is actually right. Your PO brings what the business needs; how it gets built is yours. An agent will build exactly what you specify, beautifully, even when what you specified was the wrong shape — so the work is getting from "they need this" to a spec precise enough that the right thing comes out the other end. That is the hardest hour of your week and the one nothing automates.
• Architecture. Agents are excellent inside a well-shaped system and quietly destructive in an unshaped one. Someone has to decide the shape, hold the line across a codebase for years, and know which of today's shortcuts becomes next year's rewrite.
• Judging the output. Agent code is confident whether or not it is correct. It compiles, it passes the test it wrote for itself, and it is subtly wrong in ways only someone who understands the domain will catch. This is the single most valuable thing you do here, and it gets more valuable as the agents get faster, not less.
• Accountability. When something breaks in production, an agent does not get called, does not apologise to a user, and does not decide whether to roll back. A person owns that. Here, that person is you — and ownership is not something we intend to hand to a model.
• Everything human. Disagreeing with your PO well and being listened to, telling them a feature is a bad idea before it is built, mentoring whoever joins after you, and knowing when the honest answer is "this needs rewriting".

Our honest position: we are AI-native because it makes a small team capable of far more than its size — not because we think engineers are the expendable part. We are hiring fewer, better engineers and giving each of them more leverage, which is the opposite of hiring fewer because we need them less. You will do less typing and considerably more of the work you probably went into engineering for.

The Mainloop Barcelona certificate

Something we are building alongside the team, and we think it is genuinely unusual.

Over your first two to three years here you work through a defined body of knowledge — our architecture, the agentic build method, how to take a product from an idea to something a business depends on, and how to run it well. When you have covered it and can demonstrably run a project our way, you are awarded the Mainloop Barcelona certificate.

It is yours. It goes on your CV, and we intend to make it mean something in this market — a signal that the person holding it knows how to build production software with AI agents to a standard, not just prompt their way to a demo. We are investing in making it prestigious, because a team whose alumni are sought after is a team good people want to join.

How we build — and how the standard changes

We have a settled stack, and it is the same in most repos, deliberately. Every project starts from the same scaffold, and shared code lives in shared packages everybody publishes to and everybody uses. The payoff is real: a two-person team can pick up a product they have never seen and be useful the same day, which is the only reason a team this size can own this many products — and it is what makes moving between projects painless rather than a month of ramp-up.

It is a default, not a straitjacket. Some projects genuinely need something else — a workload that is properly Python, a runtime that has to be at the edge, a client constraint we did not anticipate. When that is the case we adapt, deliberately and with the reasoning written down. What we do not do is re-decide the same five questions on every new repo out of habit.

And you get a say in what the standard is. Anyone can propose a change: something new that is genuinely better, something we should upgrade to, something we got wrong. A proposal gets researched properly against the alternatives, it gets an answer, and if the answer is no you get the reasoning. Several of the choices above will be different in two years, and the people changing them are the engineers on the team.

Things worth knowing up front

• Nobody is on call. Ever. No rota, no pager, no phone number. Alerts post to a team channel and wait. If something breaks at 3am on a Saturday it is fixed on Monday morning — deliberately. We protect against that with engineering, not with people's evenings: infrastructure as code, restores we have actually tested, one-click rollback.
• You own your product's incidents during working hours. The other side of the same coin — support is not shipped off to a separate team; it is part of owning the thing, and it is what keeps you honest about quality.
• We are building the team this year, and you will shape how it works. Some of our processes are written, some are not, and the ones written after you arrive will have your fingerprints on them. If you have ever wanted a say in how an engineering team actually operates, this is the window.

What we are looking for

Read this as a description of the engineer you will be here, not a checklist you have to arrive with. Almost nobody ticks all of it on day one, and we would rather hire someone with the instinct and train the rest — that is a large part of what the certificate is for. If several of these are true of you and the others sound like things you want to get good at, apply.

• You have owned something and can call it yours. It genuinely does not matter whether that was at a company, at university, or a side project you started alone at a kitchen table — what matters is that you made the decisions, lived with them, and can talk us through the ones you got wrong.
• You are comfortable across the front and the back of a web application. We do not split those roles. Strong TypeScript if you have it; if your language has been something else and you are good, say so.
• You test properly — unit tests and end-to-end / smoke tests against the real running thing. An agent will write most of them; making sure the coverage is actually there is your job, and you can look at a suite you inherited and say why it is a bad one.
• You use coding agents in your work and you read their output like you would a colleague's.
• You can pick up a codebase you did not write and explain what it is doing before you change it.
• English, fluently. It is our working language — we work across roughly fifteen countries. Spanish is genuinely useful day to day. Catalan is not required.
• Barcelona. This is a team that sits together, especially in its first year.

For the four junior seats specifically, read the list above as the direction of travel rather than the entry price. What we actually need on day one is narrower and we will say it plainly: you can build a working web application front to back, you have used a coding agent seriously enough to have opinions about where it goes wrong, and you want to get good at this faster than a normal job would let you. A degree, a bootcamp, a self-taught route and a stack of side projects are all fine. Years of production ownership are not expected — that is what the senior seat and the certificate are for.

We do not care what you studied. We care what you have built and whether you can talk us through the decisions in it.

How we hire

Our process is unusual, so here it is up front. Four rounds, and none of them is a puzzle.

• Fifteen minutes with Edouard. A short first conversation — who you are, what you are after, and what this actually is. Enough for both of us to work out whether the next one is worth an hour.
• A thirty-minute conversation. What you have built, how you work, and how you think about it. We will ask you to walk us through something you built and then to justify a specific decision inside it. There is no way to prepare for that and it is not meant to catch you out; it is how we tell understanding from familiarity.
• A conversation with our Casablanca team. The group has run a tech lab there for more than eight years. You get people who have run production at real scale asking their own questions — and you get to ask them yours, including the ones you would rather not ask the person hiring you.
• A project. We give you a brief and a working environment to build it in, with Claude Code already set up and wired to a key, so you are building the way we actually build rather than talking about it at a whiteboard. It is real work rather than a puzzle, you do it on your own schedule — no week off, no flights, nothing that requires you to already be free — and we go through what you built together afterwards.