A year ago I wrote a blog post on context engineering. It ended with a promise: we would see how much of our work we could actually hand over to AI, and "come back to this later".
This is later.
In one year, the way developers at Blastic work has changed more than in the ten years before. Not because the tools got smarter (they did), but because we changed what we give them. This article is about that shift in our AI-assisted development workflow: from writing code to orchestrating the people, knowledge and tools that produce it.
A year ago, we wrote code
For most of my career, development followed a predictable loop. Requirements came in, designs followed, we analysed and wrote the code, tested it, fixed it and shipped it. Frameworks evolved, build pipelines got faster, browsers got better. But the relationship between the developer and the code stayed the same: if a line existed, someone had typed it.
AI was already around. We used it the way most teams did: as a smarter autocomplete, or a chat window to paste an error into. Useful, but it sat next to the work, not inside it.
Today, we orchestrate
Today, most of the code in our projects is generated. A developer describes the change, points to the right files, tickets and designs, and reviews what comes back. The AI reads the codebase, makes changes across files, runs the build and writes the documentation.
That sounds like the developer does less. In practice the developer decides more. Every generated change still has to be understood, checked against the architecture, tested and accepted, by a person who knows what "good" means for this product and this client. What changed is where the time goes: less typing, more thinking, reviewing and deciding.
How we approach it: context first
The biggest advantage we noticed immediately: the quality of the output depends far less on the model than on the context you give it. An AI that doesn’t know your architecture, your conventions or last week’s decisions will produce code that looks right and isn’t.
So we started treating context as part of the project, versioned alongside the code:
- Project instructions describe the architecture, the build commands, the conventions and the things that must never change.
- A task file per ticket records the goal, the files that changed and the decisions made along the way. The next task starts from that record instead of from memory.
- Rules from mistakes. Every time the AI gets something wrong in a way that could happen again, the lesson becomes a rule. The same mistake rarely happens twice.
- Connected sources. Tickets, designs and the CMS are no longer things a developer copies text out of. The AI reads them directly, through standard connectors.
None of this replaces the knowledge of the team. It makes that knowledge available, at the moment it’s needed, to a tool that would otherwise guess.
How context engineering is evolving
The term "context engineering" took off in June 2025, when Shopify CEO Tobi Lütke and Andrej Karpathy argued it describes the real skill better than "prompt engineering". Karpathy’s definition: the art and science of filling the context window with just the right information for the next step. Our first article was written in that moment.
A year later, I see three shifts:
- From prompts to systems. A good prompt helps once. A good context helps every task after it. The work moved from crafting messages to building a structure the whole team uses.
- From copying to connecting. The Model Context Protocol (MCP) gave AI tools one standard way to reach other systems: tickets, design files, a CMS, a database. In December 2025 it moved to the Linux Foundation’s new Agentic AI Foundation, backed by the major AI vendors. That matters: it’s becoming infrastructure, not a vendor feature.
- From context to harness. The context is now part of a larger harness: instructions, reusable skills, checks and review steps around the AI. The first project pays for building it. Every project after that starts further ahead.
How our AI-assisted development workflow is evolving
Our workflow now looks less like a production line and more like a feedback loop:
- Intent: a person decides what needs to happen and why.
- Context: the right tickets, designs, code and earlier decisions are made available.
- Generation: the AI proposes the change.
- Review and testing: a person checks it against the architecture, the design and the client’s reality.
- Recording: decisions and lessons go back into the context.
Step 5 is the one most teams skip, and it’s the one that makes the next loop faster.
Content no longer waits, and doesn’t hold up development
One change surprised us most: how we deal with content in a CMS.
Before, development depended on content. To build a page template, someone first had to create pages, fill in fields and upload images in the CMS, often with placeholder text that had to be cleaned up later. Developers waited for content, or created it by hand.
Today the AI connects to the CMS through MCP. It reads the content model, then creates and fills content itself, based on the design: the structure, headings and components in the design file become real content items in the CMS. Development and content creation now run side by side, and test content is consistent, complete and easy to replace. The same connection works after launch: updating meta descriptions across a site, restructuring a page or checking every page for broken markup becomes a task of minutes, reviewed by a person before it’s published.
Why the scope gets processed faster
What used to cost the most time in a project wasn’t typing code. It was everything around it: reading a ticket and the three tickets it refers to, finding where a change belongs, checking what else it touches, writing the documentation afterwards.
That’s exactly where AI with the right context is strongest. It can read a whole codebase, the ticket history and the design before writing a line. A change that touches ten files is no longer ten times the work. Analysis that took a morning takes minutes. That’s why we can take on more scope in the same sprint, and also scope we would have postponed before: accessibility fixes, structured data, security headers, the cleanup nobody gets to.
Why developers see big speed gains
Ask developers and most will tell you they’re much faster. In a 2026 survey by METR among 349 technical workers, the median self-reported speed gain was 3x. And it feels true: code appears in seconds, boilerplate is gone, and a task that looked like a day of work is done before lunch.
For individual tasks, especially well-defined ones in a well-documented codebase, that gain is real. We see it every day.
Why we don't see that gain everywhere (yet)
And yet, the projects aren’t finishing three times faster. There are good reasons why.
Perception runs ahead of measurement. In a 2025 randomised study by METR, experienced open-source developers took 19% longer with AI tools, while believing they had been 20% faster. METR has since called that result outdated: developers are likely sped up now, but its new data gives only an unreliable signal of how much. The same researchers note in their survey that the value people report (a median of 1.4 to 2x) is a lot lower than the speed they report (3x). The honest conclusion: the feeling of speed is not a measurement.
The bottleneck moves to understanding. It’s tempting to let AI do the analysis and the build in one go. On paper that’s the fastest route, in practice it’s where things go wrong. Skip the review in between, and the AI makes choices you never saw, based on challenges you don’t know. When the result appears, you have to catch up on the understanding at the last step and correct what you would have done differently, in code that’s already built. In our experience, that often costs as much time as reviewing the analysis first, or more. So we review each analysis before we build, in short loops, and test before we ship. From the outside, the work looks done the moment the output appears. It isn’t: fast output loses the connection with understanding. And what AI receives is already our translation of what a client wants. Developers are translators of expectation and emotion. That still takes time, but the time has moved to the very beginning: context, analysis and understanding.
AI amplifies what’s already there. Google’s DORA 2025 report puts it plainly: AI doesn’t fix a team, it amplifies what’s already there. Strong teams get better, struggling teams see their problems intensify. The report links AI adoption to higher throughput, but also to lower delivery stability when testing and feedback loops aren’t in place.
Trust has to be earned. In the Stack Overflow Developer Survey 2025, 84% of developers use or plan to use AI tools, yet more of them distrust the accuracy of the output (46%) than trust it (33%). We recognise that: the review step can’t be skipped.
The rest of the project didn’t speed up. Feedback rounds, approvals, content decisions and meetings run at the same pace as before. A developer who’s twice as fast doesn’t make a project twice as fast.
So where’s the gain? Not in speed, but in breadth. Take a typical feature, as an example from experience: building it used to take three days for an okay result. Today the build takes a day and a half, and the result is better. But the time we win goes straight into a new feedback loop: automated tests, triage and rework, and documentation. So we end up at three days again. It doesn’t go faster, it goes broader. And you get a richer product.
What we achieved in one year
Looking back over the year, the gain isn’t one number. It’s a different starting point:
- Every project has a context layer: instructions, task records and rules that the whole team, and its tools, build on.
- Quality checks that used to be "nice to have" are part of the routine: security headers, accessibility, performance and structured data get checked on every change, not once before launch.
- Content and development no longer wait for each other.
- Knowledge doesn’t leave with a conversation or a person. It stays in the project.
- And developers at Blastic spend their time where it matters most: understanding the problem, making the decisions and checking the result.
The first project carried the cost of discovering this way of working. The ones after it started further ahead.
Where this is heading
Predictions in this field age fast, so I’ll keep it to what I think is likely in the next few years:
- Longer, more independent tasks. AI will take on work that runs for hours instead of minutes: a full migration, a complete test suite, an accessibility pass across a site. The human role shifts further towards setting intent and reviewing outcomes.
- Context becomes a product. Teams will maintain their context as carefully as their code: reviewed, versioned and shared across projects.
- Everything connects. With an open standard like MCP, every system a project touches (tickets, design, CMS, analytics, hosting) becomes something an AI can read from and act on, within the limits you set.
- Measurement catches up. Today we mostly have self-reports and small studies. Teams will learn to measure what actually matters: lead time, quality and stability, not lines of code.
- The developer becomes an orchestrator. Technical knowledge doesn’t become less important. It becomes what allows a much larger set of tools and information to work together. Knowing which instrument to use, when, with what input, and when not to trust it: that’s the job.
The human stays in the loop
The goal was never to remove the developer. It’s to make the system around the developer more capable, and to keep improving it with every project.
A year ago, we wrote the code. Today, we decide what gets built, give our tools the context to build it, and take responsibility for the result. That’s not less work. It’s different work, and I wouldn’t go back.
Contact us
Want to know what an AI-assisted workflow could mean for your team or your platform? Get in touch.
Let's generate your next project
From design to headless CMS, with people making every decision
We recently built a multibrand platform this way: AI read the designs, created the tickets and generated the components, while developers at Blastic set the architecture and reviewed every step.
Halfway through, the pace felt slow to the client. The result won them over, and their next project followed.
Curious what this could mean for your project? Tell us about it.