This newsletter is sponsored by Unblocked.
A Pile of MCP Connectors Is Not a Context Engine
Your team connected Slack, Jira and GitHub over MCP, and engineers still spend their time steering agents to the right answer.
This article looks at why: connectors fetch from one tool at a time, so every agent stitches the pieces together itself, trusts the first doc that looks right, and adds a search to your token bill each time.
Read what changes when a context engine sits on top of your connectors: the same coding task finished 83% faster at 48% lower cost.
Thanks to Unblocked for sponsoring this newsletter. Let’s get back to today’s thought!
Intro
My book The Multiplier Mindset published by O’Reilly has recently been released, and has also been a #1 Bestseller (or close to) on Amazon for the past weeks.
In the part 2 of the book, I feature 8 case studies of successful multipliers (tech leads, engineering managers, staff engineers, and architects), looking at:
How they multiply others
What makes them successful
How they use AI
Their advice to engineers and engineering leaders to thrive in the AI era
Today, I am sharing the case study of Jarosław Żołnowski, Team Lead and Architect at XTB, which is included in the book.
Let’s start!
What Jarosław Żołnowski Does?
Jarosław Żołnowski’s work sits at the intersection of architecture, leadership, and delivery.
As an engineering team lead and architect, he operates across the technical and human dimensions of XTB’s systems, which comprise, in his words, “a regulated trading platform with real money flowing through it.” Here’s how he describes it:
The platform I work on is, in plain terms, two systems glued together. There’s an AngularJS 1.x host that’s been in production for over a decade. And there’s the newer stack: Angular 21+, Nx monorepo, module federation, and micro-frontends talking to the backend over gRPC-web and to each other over an EventBus.
We’re slowly moving everything from the old world to the new one without taking the platform down. This isn’t a hobby project. People open it every day to execute orders worth a lot of money.
There are latency dashboards watching us, compliance officers watching us, and support agents who get paged at 2:00 A.M. because Asian markets are open and something hiccupped. We move fast when we can, but the cost of being wrong is high. It shows up in lost trades, in regulator emails, and in customers who quietly leave.
When the stakes look like that, “Just let the AI build it” stops being a productivity strategy and starts being a way to get yourself in trouble.
On the technical side, Żołnowski designs and guides the company’s longterm architectural strategy. That includes deciding what technologies to use, designing how systems communicate, determining how teams will evolve the codebase over time, and making the right trade-offs among speed, safety, and maintainability.
He also designs and maintains AI context infrastructure (skills, workflows, commands, hooks, MCP server integrations, and agent configurations) so that every engineer on the team is working from a shared, elevated baseline.
How Żołnowski Succeeds In His Role
Żołnowski finds great value in Spec-Driven Development (SDD). To explain why, he shared a story about “the week that made me stop coding first.” Here’s what he said:
A few months back, during a quarterly goals meeting, one of our senior consultants was visibly frustrated. He had spent the entire week migrating a module from our legacy AngularJS app into a modern Angular microfrontend.
Thanks to AI assistance, the code was flying together. By Wednesday, he already had the component, service, state management, some tests, and a draft merge request ready to go.
By Thursday, he was deleting almost everything he had just built. The gRPC contract he’d assumed for one endpoint turned out to be wrong.
The component was using an async pipe instead of signals, which we’d banned in new code months earlier. And the EventBus topic he’d subscribed to had been renamed two sprints earlier.
None of this was the AI’s fault. There just wasn’t a spec. That week is the reason I now treat SDD as the single most important habit I’ve built since AI tools became serious.
Not as a heavyweight process. Not as waterfall in disguise. Just a three-phase contract that goes Requirements, Design, Tasks, and that every real piece of work on our platform has to pass through before code gets written.
In practicing SDD, Żołnowski has found that keeping the specs updated is key: “We version them in the monorepo alongside the code, review them when they change, and delete them when the work ships.
A stale spec is worse than no spec, because it gives you false confidence.” That doesn’t mean, however, that teams should spend a great deal of time writing and perfecting specs.
“The point of the spec,” he points out, “is to unblock execution, not replace it. If your spec is taking more than about 10% of the time you expect implementation to take, you’ve probably overengineered it. Most of ours fit on two pages and take half a day to write.”
How He Multiplies Others
SDD is a naturally team-oriented method of development, and Żołnowski finds that it presents plenty of opportunities to encourage the whole team, including its junior members, to think critically and push back when they see problems.
“Specs have to be challenged, not rubber-stamped,” he explains. “If a junior engineer reads my design and pushes back on, say, the state ownership choice, that pushback is usually the most valuable conversation of the whole project.
I’ve lost count of how often someone with fresher eyes has spotted an assumption I had quietly inherited.”
Building a psychologically safe environment
Pushing back can sometimes be uncomfortable, but “growth does not happen inside the comfort zone,” Żołnowski says.
“I am actively trying to create environments where it’s safe to try, fail, and learn. This means celebrating experiments that didn’t work out, normalizing asking questions, and making it clear that admitting uncertainty is a sign of intellectual honesty, not weakness.”
This approach encourages knowledge sharing at all levels of the organization and in a variety of forums, from one-on-one mentoring to workings and “guilds,” where teams from different projects meet to discuss real problems and solutions.
“Learning from each other is the best thing you can do,” he says. He cites code reviews as another example of this principle, describing each code review session as an “investment in the reviewer and the reviewee equally.”
Using the Socratic method
Żołnowski multiplies the value of mentoring sessions by using the Socratic method, making sure the engineer asking him a question understands the reasoning behind his answer by asking them questions like “What options did you consider? What trade-offs did you weigh?”
The goal, he says, is to make sure that “the next time they encounter a similar problem, they don’t need me.”
Building a culture where the best idea wins
Perhaps the biggest multiplier he cites is culture. “The most scalable thing I can build,” Żołnowski told me, is this:
An engineering culture where people hold each other to high standards, share knowledge proactively, and feel safe taking ownership.
My nonnegotiable part of that culture is the principle that “the best idea wins,” regardless of who proposes it.
Title and experience inform credibility, but they do not decide the outcome. This creates an environment where people speak up rather than defer and where the best thinking surfaces regardless of where it comes from.
How He Leverages AI
When AI assistants first became widely accessible, the interaction model was simple and limited: you opened a chat, wrote a prompt, got an answer, and started a new conversation.
Every session was stateless. Every prompt had to carry all the context the AI needed, and that context was entirely dependent on how well you could describe your prompt from scratch.
This created a fundamental asymmetry: the quality of the output was almost entirely determined by the quality of the prompt. Teams tried to compensate by writing longer, more detailed prompts.
Some got good at it, but the knowledge was always in people’s heads, not in the system.
Treating AI as a system to configure
“The shift that changes everything,” Żołnowski explains, “is treating AI not as a chatbot you query but as a system you configure. It mirrors exactly how good software engineering works. You invest in the infrastructure, designing, flow, and architecture once, and the entire team benefits continuously.”
Sharing system knowledge
He emphasized the importance of sharing knowledge here, too:
The team shares a common CLAUDE.md file that encodes architectural decisions and constraints, a command library (so no one has to remember or reexplain workflows), skill files that carry domain expertise that used to live only in senior engineers’ heads, and hook configurations that enforce safety constraints automatically.
XTB’s monorepo thus functions as a permanent memory that is focused on what the AI must always know. Żołnowski explains further:
Specialized subagents, a code reviewer, a security auditor, and a test writer, each operate with their own scoped instructions and their own “brain.”
Hooks add automated validation gates that run before and after AI actions, making behavior predictable and safe. And MCP server integrations connect the AI to external systems like GitLab, Angular, Nx, or our techdocs server.
Effective context management and session structuring are crucial for an AI to maintain coherence throughout long, intricate operations, preventing it from degrading into confusion mid-task.
The results have shown clearly in the work that emerges. Junior engineers are more effective, Senior engineers are freed up to focus on design and other tasks that require their full expertise, and the organization moves faster overall, “not because individuals are faster but because the shared system is faster and consistent.”
His Advice For Engineers
Żołnowski’s advice to engineers includes the following.
Learn good communication skills
He stresses the importance of learning to communicate clearly. In particular, he encourages his team to get skilled at conveying complex technical ideas at a level of abstraction that’s appropriate to the audience, whether that’s a fellow engineer, a product manager, or a nontechnical executive.
Prioritize good system design
He also recommends that engineers spend more time designing solutions before implementing them. “AI does not replace architectural thinking,” he says.
“It amplifies it. An architect who designs clearly and then leverages AI to execute will produce better outcomes than either alone. An engineer who skips design and asks AI to ‘just build it’ gets technically plausible but architecturally incoherent output,” and risks discovering their mistakes later in the process, when the cost of fixing them is far higher.
“The up-front cost is real,” Żołnowski notes. “The compounding return is larger. Every session, every team member, and every future task inherits the work done once at the design stage. Prompting without context design is the AI equivalent of coding without architecture: fast to start, expensive to maintain.”
Focus on fundamental programming principles
“The single most valuable skill a software engineer or architect can develop,” Żołnowski says, “is a deep understanding of general programming principles instead of any framework API. The framework teaches me how to use one specific tool. The fundamentals teach me how to think.”
Knowing only one or a few frameworks locks developers and engineers into a single stack, but deeply understanding their underlying concepts “allows us to move between ecosystems without being lost.”
Stay current in the field and evaluate the newest options
Finally, Żołnowski strongly recommends keeping your technological knowledge current. “Technology never stands still,” he points out, so staying current is a “core responsibility.”
That means reading release notes, following core team discussions, running experiments in controlled contexts, and updating team standards when the evidence supports it.
But architects can’t stop at just knowing the landscape.
They need to be able to evaluate the options: distinguishing genuine improvements from hype, understanding why a new approach is better and under what conditions, and knowing when the cost of adopting it is justified versus when the current solution is good enough.
Remember that tools like AI or different frameworks do not guarantee quality. They lower the floor of what’s possible, but they raise nothing automatically.
A good engineer with a simple tool produces better outcomes than a weak engineer with a powerful one.
Last words
Special thanks to Jarosław for sharing all these insights with us! If you haven’t yet, make sure to check out the book The Multiplier Mindset, where you can find more case studies similar to this one.
Liked this article? Make sure to 💙 click the like button.
Feedback or addition? Make sure to 💬 comment.
Know someone that would find this helpful? Make sure to 🔁 share this post.
Whenever you are ready, here is how I can help you further
Interested in sponsoring this newsletter? Check the sponsorship options here.
Check out my book “The Multiplier Mindset” coming out later this year, here.
Take a look at the cool swag in the Engineering Leadership Store here.
Want to work with me? You can see all the options here.
Get in touch
You can find me on LinkedIn, X, YouTube, Bluesky, Instagram or Threads.
If you wish to make a request on particular topic you would like to read, you can send me an email to info@gregorojstersek.com.
This newsletter is funded by paid subscriptions from readers like yourself.
If you aren’t already, consider becoming a paid subscriber to receive the full experience!
You are more than welcome to find whatever interests you here and try it out in your particular case. Let me know how it went! Topics are normally about all things engineering related, leadership, management, developing scalable products, building teams etc.







