AI engineering, explained for those discovering the craft

No. The GSD protocol frames every step: written context, reviewed plan, execution, human verification. The agent speeds up execution; it never has the last word. The diagrams above show who owns which step.

Without that frame, an agent drifts: it invents a rule, skips a constraint, delivers something that works technically but misses the goal. Review is not a luxury — it is what separates a studio from a text-production machine.

In practice: the human writes the brief and accepts the plan; the agent produces; the human reviews the deliverable before anything goes live. If a step has no named owner, we don't start it.

In part. It is a profile halfway between developer and analyst: they code, they set up measurement, they can read a conversion funnel and a statistical test — and they steer agents rather than writing everything by hand from start to finish.

It is not someone who merely prompts ChatGPT well, nor a researcher who trains models. The craft, here, is to take a project through to a measurable result: a new page version live, a clickable prototype, a dashboard that answers a question.

If you only need a developer to work through a ticket list, an in-house team or a services firm will do better. If you need someone who connects measurement, product and agents, that is this studio.

No. This is neither research nor data science in the academic sense: we don't build a homemade AI model. We assemble existing models — from Google, OpenAI, Anthropic — and analysis tools into a process that produces a deliverable.

The value is not “AI”. It is the protocol: a fresh memory at every step, several research tracks in parallel, a reviewed plan, execution in waves, a verification. A model without a frame produces text; a protocol produces a site, a test, a screen.

If what you need is a model trained on your own data — fine-tuning — that is not the offer. We can, however, frame how agents rely on your data, locally, without sending it just anywhere.

Your data extracts are analysed locally, on a studio machine, with classic analysis tools. No client data is sent to an AI model without prior written agreement. The perimeter — which files, which columns, which tool — is set at kickoff.

That is deliberately stricter than “we'll paste it into ChatGPT”. A CRM export, a conversion file or a navigation log has no business in a consumer tool by default. If a cloud agent is useful, we say so, we limit the columns, we anonymise what needs it.

You remain the owner of the data and the deliverables. The studio trains nothing on your files and does not reuse them on another client.

Because instrumentation replaces coordination. One counterpart, tooled agents and a GSD protocol hold a small team's pace, without the cost or the delays of a multi-layer structure.

The hard part is no longer writing the spec: it is executing in parallel and verifying. That is why GSD launches several research agents at once, chains execution waves and requires a verification — rather than adding people and meetings.

There is a ceiling: an international programme with twenty contributors is not the right case. A conversion funnel, a product, an internal tool, yes. The call is there to see which side you are on.

GSD is a lightweight orchestrator: a fresh memory at every step (to keep the conversation from degrading), several research tracks in parallel, a reviewed plan, execution in waves, a verification. It is not one more tool for you to learn — it is the studio's internal kitchen.

GitHub Spec Kit, OpenSpec, Taskmaster or BMAD do something else, and they do it well: spec first, delta against an existing product, task tree, one agent per role. They help write the plan. After two years of real use, the real difficulty is elsewhere: execute in parallel and review — hence GSD.

You don't have to pick the tool. You see deliverables and a cadence. The detail on alternatives is in the “Alternatives” tab higher on this page.

It is a simple rules file the agent must follow for a given type of deliverable: a conversion audit, a tagging plan, a prototype screen. The studio calls it a “skill”. Without it, the agent improvises; with it, it repeats a gesture already proven.

Studio projects share a library of these files. That is what avoids reinventing “how we write a test” on every engagement. It does not replace review: it makes execution consistent.

You have nothing to maintain. You benefit from the fact they exist — and every engagement that goes well enriches one, instead of staying in one person's head.

For agents: Cursor, Claude Code, Kilo Code, Copilot, Cline, the GSD protocol and project rules. For analysis: Python and SQL. For measurement: GA4, GTM and Looker Studio. For pages: HTML, Tailwind, sometimes Webflow.

The list evolves; the protocol stays. We don't impose our tools: we adapt to what you already have — your CMS, your database, your ad account. The tool serves the goal, not the other way around.

If a tool is a lock (licence, data that cannot leave), we treat it in the scoping. No surprise on day 3.

It depends on the deliverable, not on “AI”. A clickable prototype: a few days to a few weeks. A first readable conversion test: often a few weeks, the time to accumulate enough visitors. A set of well-ranked pages: months. Usable live software: a few weeks of development after a scoped prototype.

Agents speed up production, not the pace at which your traffic arrives nor the time a test takes to become reliable. Promising a Google #1 in fifteen days because we write faster would be a lie.

The first visible effect, though, is fast: a written scoping within 48h after the call, with the problem, the KPI and the first step.

Yes — that is even the most frequent case. A conversion funnel leaking visitors, a GA4 setup nobody trusts, a mockup never tested with users, a product roadmap stuck. We start from what exists; we don't ask you to start over.

AI engineering then serves to accelerate one piece of the workstream — data analysis, page variants, screens, content — while your team continues the rest. The studio does not need to “take over the account” to be useful.

If the workstream is already well framed by an agency or an in-house team, we fit their rituals. The call is there to see where we plug in, not to rebuild everything.