When a journalist asks four senior engineers with ten or more years of production experience what keeps them relevant in 2026, you expect four different answers. You get one. AI has made coding skills almost irrelevant, ownership has not moved an inch, and the engineer who can do both still gets the call. Marko Crnjanski’s interview in ShiftMag on April 24, 2026 sat down with Denis, Marina, Marko, and Mario, all 10+ year veterans, and the convergence is the story. They do not agree because they coordinated answers. They agree because the underlying job changed in the same way for everyone running production code in 2026.
This piece reads their answers as a buyer-side and hiring-side document, with quotes verbatim and the polemic mine. If you are filtering senior contractors, paying senior salaries, or carrying a pager for a system that ships AI-generated code daily, the four-way convergence is your signal.
How senior developers stay relevant for years
ShiftMag’s editor Marko Crnjanski interviewed four engineers, each with ten plus years of production experience, on three questions: what kept them relevant, whether long-term success leans specialist or generalist, and how AI tools are changing developer careers. The responses were edited but not collapsed. Read end to end, the article reads less like a panel and more like a focus group that did not know it was one.
Denis on staying relevant: I was always looking for ways to improve my workflow, so I could spend more time on the interesting, creative parts of the job and less on repetitive, routine tasks. I focused on really understanding problems and possible solutions, which meant building deeper knowledge rather than relying on quick fixes from the internet.
Marina on the same: Staying relevant over the years came down to curiosity and hands-on learning. I regularly read blogs and watch online conferences to keep up with new technologies, but I learned the most by trying things out through small POCs.
Marko on the same: For me it’s a combination of continuous learning and a strong focus on fundamentals. I always tried to explore new technologies and different domains, but with an emphasis on really understanding the core principles behind them.
Mario on the same: Talking to other people, watching what others build, and experimenting myself plus exploring open source projects, YouTube videos, and Udemy courses on 2x speed to quickly understand what’s possible with unfamiliar tools.
Each of them, asked separately, came back to the same triad: deeper knowledge over quick fixes, hands-on production experience, and learning that moves between domains rather than down a single shaft. The four also worked across different stacks (Marina front-end heavy, Mario from Linux internals up, Marko cross-stack, Denis closer to product), which makes the convergence stronger, not weaker.
Will AI replace senior developers
The strongest line in the article comes from Marina: AI tools will significantly change how developers work, but I don’t see them replacing strong engineers. Instead, they will amplify those who understand what they are building.
That word, amplifier, is doing a lot of work. An amplifier multiplies signal. It also multiplies noise. The buyer-side reading is that AI does not raise a junior to senior on its own, and it does not flatten the seniority curve. It steepens it. The senior who knows what to ship gets faster. The junior who does not know what to ship gets faster at shipping the wrong thing.
Denis goes further, with the most provocative quote in the piece: AI tools have made coding skills almost irrelevant. Still, other skills and practices related to quality, such as trunk-based development, TDD, continuous delivery, modularity, cohesion, DDD, etc., are more valuable than before. AI tools are a powerful amplifier, and they need guidance.
Read that line slowly. He is not saying coding does not matter. He is saying that the act of producing valid syntax in a known language has dropped close to zero in marginal economic value, while the surrounding craft (test discipline, deployment cadence, architectural cohesion) has gone up. This is consistent with what Polish recruiters told No Fluff Jobs in their 2025 to 2026 market report: programmers are increasingly operators of LLMs and architects of automation, not code typists. Just Join IT’s report puts it more bluntly: prompt engineering became as important as classical programming for a year, then dissolved into the day-to-day, and what remained was the ability to direct AI at problems that mattered.
For AI-ready commerce and Universal Commerce Protocol work on WooCommerce or headless WordPress delivery where the public surface is decoupled from the editing stack, Marina’s amplifier framing is the operational truth. The AI ships code. The senior decides whether the code belongs in this codebase at all.
Who owns AI-generated code in production
The cleanest articulation of the human side of the AI shift comes from Mario: The amount of generated code is huge, yet humans still need to review, understand, and own it. AI isn’t the one waking up when something breaks. Creating PRs with AI is easy, being responsible for them is another story.
This is the line you put on the buyer-side hiring matrix. Anyone who carries the pager for a production system in 2026 understands it instinctively. AI extends the surface area faster than the team can grow. The team’s responsibility for that surface area does not extend at all. The result is a compression: senior engineers spend more of their day reviewing, owning, and refusing AI output, and less of it writing code from scratch. The shape of the work is closer to a senior code reviewer in a high-frequency PR shop than to a senior individual contributor of five years ago.
Marko makes the same point in different language: When something breaks at 2 a.m., it’s still engineers who make decisions and take responsibility. AI is powerful, but only as effective as the person using it.
For my WordPress security audit and WordPress maintenance support clients, this is the operational difference between a senior contractor and an AI-augmented intermediate. The senior is the one whose name goes on the runbook entry and whose phone rings when the runbook fails. AI does not staff that role.
M-shaped vs T-shaped developer
The middle of the article is the part hiring managers will recognise least. The four veterans were asked whether long-term success leans toward deep specialist or broad generalist, and three of the four say neither. They describe the M-shape: depth in multiple domains, accumulated by following problems rather than by career planning.
Marina starts with the canonical T-shape and says it stopped describing her work: Earlier in my career, I believed that being a T-shaped developer was the ideal path and I assumed that trying to learn more than one thing deeply would only lead to superficial knowledge and that focusing on a single specialization was the safest way to grow. Over time, my view changed. Through real-world experience, I realized it’s possible to build strong, meaningful expertise in multiple areas without losing depth.
Mario, with twenty plus years across Linux internals, networking, compilers, containers, orchestration, and distributed systems, describes the same arc: So my view has evolved, I started as a T-shaped believer, and somewhere along the way I became something closer to M-shaped. Not by design, but by following the problems.
Marko frames the integrating principle: What ties all of this together is problem-solving. Technologies change, but problems remain. Being able to learn continuously, adapt, and apply concepts from one domain to seemingly unrelated problems becomes incredibly valuable over the long term.
This is the technical justification for the composable engineer pattern that Polish freelance brands like wppoland.com sell. WordPress sits next to Astro, Next.js, Cloudflare Workers, Universal Commerce Protocol, NIS2 readiness, and accessibility audits, not because the engineer collected stacks like badges, but because production problems crossed those boundaries. An M-shaped CV is harder to fake than a T-shaped CV; the depth in each spike is testable in a reference call.
Junior developer jobs in the age of AI
The hardest line in the article is also from Mario, and it is not optimistic: Young developers are in a tight spot, suddenly expected to skip writing code by hand but still have the same depth of understanding. And I’m not sure you can skip that part. There’s something about writing code by hand, hitting a wall, debugging it yourself, and feeling the pain of it not working that builds intuition you can’t shortcut. Even if AI is faster and easier.
For Polish junior engineers, the empirical evidence backs this. No Fluff Jobs reported junior offers fell from earlier years to 5.3 percent of all openings in 2025, while senior offers held at 59.7 percent. Just Join IT’s tracking puts junior offers at 4.79 percent of theirs, with senior at 51.48 percent. The pipeline that produced senior engineers historically (junior writes code by hand, hits walls, learns) has been disrupted at the entry layer because the AI-augmented junior produces output that looks senior on the screen and is not.
Marko’s recommendation in the article is the most pragmatic: For junior developers, don’t skip the fundamentals. Expectations are higher than ever, but strong foundations are key for a sustainable career. The good news is that access to knowledge and AI tools is better than ever. Use AI to accelerate learning, not replace understanding.
Mario’s tactical recipe: Write as much code by hand as you can. Use AI to review it, ask for other options, and have it challenge your approach, and then actually think through the answers.
If you are running a junior or mid hire program in a Polish or DACH context in 2026, this is the structure you implement, not the one you read about. AI is part of the toolchain, but the daily exercise is hand-written code first, AI as second-pair-of-eyes second.
Update, . A working paper from the Stanford Digital Economy Lab, How Does AI Change Labor Demand? Evidence from 41 Countries by Bharat Chandar and Bouke Klein Teeselink (21 September 2026, PDF), tests the same pattern on far more data: 1.25 billion job postings and 154 million employment records from January 2021 to March 2026. At foreign affiliates of multinationals that adopted generative AI, the junior share of the workforce was 1.9 percentage points lower than at comparable affiliates by March 2026. Most of the gap comes from growth above junior level: that employment rose 6.7 percent, while junior employment fell 2.5 percent, an estimate the authors say is not statistically significant. Junior in the paper means the two lowest seniority levels in Revelio Labs data built mostly from LinkedIn profiles, and senior starts at associate level, so it is not a job title. Poland is one of seven countries, out of 31 estimated separately, where the drop in the junior share is statistically significant. The authors list the limits themselves: LinkedIn over-represents managers and professionals, and the panel covers just over three years after ChatGPT. If you are buying development work, entry paths into the trade are narrowing, so the experienced WordPress developer who reads and fixes AI output on your project is the scarcer resource. The questions in the hiring section below are built to check exactly that.
Will AI take programming jobs in Poland
On 19 October 2026 the X account @dorszafranski reposted a post from the Polish subreddit r/praca (quotes translated from Polish, own translation). Its author describes himself as a senior at a large company: “For half a year I haven’t written a single line of code by hand, AI does everything for me.” He still reads and fixes what the model produces, so he ships more slowly, while “most people don’t even read it anymore”. His company has not hired juniors for two years, two mids and one senior have already gone, and the team ships more features than ever. Among developers, he writes, the main topic is exit plans from IT.
A day later @dorszafranski published his own analysis of the replies. He went through 293 comments under the post and under its quote posts by hand and left out the neutral ones. Of the 234 he rated, 156 (67%) called the bleak scenario an exaggeration, and the top comment (630 likes) called the post ragebait. Under a separate question from @FinansowyUmysl about an exit plan from IT, the most common answer, by his count, was “none”. The Jevons paradox comes up as well: cheaper code can raise demand for software.
The layoff numbers explain part of that anxiety. Connie Loizos wrote in TechCrunch on 15 June 2026 that TrueUp had counted an estimated 363 layoffs at tech companies so far that year, affecting nearly 150,000 people, a pace 44% faster than the year before. The same companies were posting record profits and revenue and citing AI as the official reason for the cuts, while skepticism grew that AI was a convenient cover story rather than the actual cause. Her example is Block: Jack Dorsey first tied its cuts to AI tools, then acknowledged that the company had overhired.
That is one anonymous account and one informal sample. It still matches what the four seniors above say: code nobody has read still has an owner, the person who gets the call when it breaks. My advice to a junior is to practise reading model output as often as writing their own code, because in the company described, reading and fixing is the part that stayed with the senior.
Why TDD and DDD matter more with AI
The least sexy and most economically loaded sentence Denis says in the interview is the one buyers should mark up. He lists trunk-based development, TDD, continuous delivery, modularity, cohesion, and domain-driven design as more valuable in 2026 than before. None of these is new. Most of them have been around since the early 2000s. The reason they reappear in a 2026 senior engineer’s vocabulary is exactly the AI shock.
Trunk-based development matters more because PR volume from AI-augmented teams is higher; long-lived branches die faster. TDD matters more because AI-generated code passes the linter and fails the spec; the spec has to exist in test form before the AI runs. Continuous delivery matters more because the rate of change is higher; the deployment surface is the only place latency can be controlled. Modularity and cohesion matter more because AI generates code that crosses module boundaries silently; without an architectural skeleton, the silent crossings turn into the ball of mud Mario described. DDD matters more because the business rules are the part of the system AI has the least access to; the senior’s value is to maintain the model.
Read this list as a buying signal. A senior contractor in 2026 who cannot describe their TDD pattern, their trunk-based cadence, and their DDD context map is not a senior contractor in 2026. They are an intermediate with AI access, which is a different price point.
Is the senior developer job harder with AI
ShiftMag’s article is generous to AI tools. The four engineers all use them. The implicit polemic, which the editor did not draw out and which I will, is that the senior engineering job in 2026 is asymmetrically harder than it was in 2022, while the junior engineering job is asymmetrically easier on the surface and asymmetrically harder underneath.
Asymmetrically harder for seniors because:
- PR review volume goes up before headcount does.
- Architectural decisions have to survive faster, more confident AI-generated alternatives.
- On-call surface grows with code volume, not team size.
- The ability to refuse a plausible AI suggestion is now a daily, unpaid skill.
Asymmetrically easier on the surface for juniors because the visible output (working code, completed tickets) comes faster. Asymmetrically harder underneath because the path from “I produced output” to “I understand the system” no longer goes through hand-written code by default. Juniors have to opt into the harder path. Few will, which is why the senior premium widens.
For Polish freelance engineers, this is the market structure that pays. No Fluff Jobs senior median in 2024 sat at 24,360 PLN B2B net per month. The 2025 to 2026 reset preserved that floor and amplified the senior share to nearly 60 percent of openings. The convergence ShiftMag captured is what those numbers feel like from the inside.
How to hire a senior developer in 2026
If you are buying senior engineering in 2026, the four-way convergence in ShiftMag gives you a clean filter:
- Ask about refused AI suggestions, weekly. Anyone who runs production code with AI assistance refuses suggestions weekly. Specifics filter out theatre.
- Read pull request reviews they wrote, not authored. Authoring a PR is now AI-cheap. Reviewing one is the senior signal.
- Walk one production incident page-to-post-mortem. AI does not staff on-call. The story they tell about a real incident is the senior signal that survives.
- Compare AI-on and AI-off output for the same task. The delta is the actual lift.
- Ask for the M-shape. Two or three deep domains with named systems. T-shape is the 2018 ideal; in 2026 it underprices the engineer who can move across the stack when the problem requires it.
The four veterans implicitly endorse a hiring funnel where the surface signals (typing speed, syntactic fluency, framework familiarity) have all been flattened by AI, and the deep signals (refusal, ownership, on-call narrative, architectural memory) have been compounded.
What is composable engineering for senior developers
The strongest single sentence in the ShiftMag piece, and the one that most directly maps to how this brand sells, is Marko’s framing: What ties all of this together is problem-solving. Technologies change, but problems remain.
The composable engineer pattern, where one senior moves between WordPress, headless front-end, edge runtime, AI integration, and compliance, is not a marketing slogan. It is what M-shaped engineering looks like when the production reality forces it. AI did not invent the pattern. It accelerated it. The four veterans ShiftMag interviewed are describing the shape of senior engineering work in 2026 from four different angles, and the shape is the same.
For a freelance engagement in 2026, the practical reading is: pay for refusal, ownership, and depth across multiple domains. The typing speed is now free.
Update, November 2, 2026: Proton’s manifesto, agent harnesses, and the Renaissance Developer
Six months after the ShiftMag interviews, the premise that senior engineering is shifting from syntax to systems architecture gained loud confirmation across the industry, along with its uncomfortable operational realities.
On November 1, 2026, Proton published the full internal memo from CTO Bart Butler: Programming is dead. Engineering is not. Butler argues that typing code is no longer the engineer’s primary job. Instead, the engineer acts as a team lead managing AI models and agents, systematically removing friction and designing guardrails. When an agent fails at user authentication or session management, the engineer’s job is not just patching the offending line. It is improving the harness: adding project rules, writing regression tests, tightening API scopes, or providing concise context. A good engineer ensures the mistake cannot recur.
At the same time, reporting by 404 Media exposed the real friction inside Proton: leadership pressure to accelerate AI adoption at the expense of security reviews, with engineers voicing concern over shortened penetration testing timelines on privacy-critical systems. Proton admitted internal communication had been too aggressive. For engineering buyers, this is a clear lesson: generating code faster without empowering senior engineers to say “no” only compounds architectural debt and deployment risk.
Similar evidence arrived across major engineering teams in late October and early November 2026:
- Amazon and the Renaissance Developer: Amazon updated its internal engineering guidance, warning explicitly against tokenmaxxing (burning tokens and generating commits merely to look productive in metrics). True value lies in combining AI tooling with domain depth, product intuition, and critical judgment.
- OpenAI and harness design: In a five-month experiment merging roughly 1,500 Codex pull requests, OpenAI found single long prompts counterproductive. The team succeeded by building a tight harness around the agent: a concise project map, automated tests, log streams, and browser-based verification.
- Anthropic and Scion monorepo scale: With changes scaling past 30,000 commits per day, the bottleneck shifted to CI/CD pipelines. Senior engineers spent their highest-leverage hours rejecting plausible Claude suggestions that worked locally but broke system boundaries.
- PostgreSQL and Robert Haas’s paradox: On October 30, veteran committer Robert Haas noted that automated bug finding by LLMs flooded the project with reports (pushing release branch changes from 724 to 1,169). Triage, verification, and careful human review became the binding constraint, threatening to delay the next major release.
The takeaway for late 2026 is clear: code generation is cheap. The architecture, the harness, the test suites, and the judgment to halt a premature rollout remain the exclusive preserve of experienced human engineers.
Sources cited:
- Marko Crnjanski, “What 4 engineers with 10+ years of experience say about staying relevant in the AI era,” ShiftMag, April 24, 2026.
- Bart Butler, “Programming is dead. Engineering is not,” Proton Blog / internal memo, November 1, 2026.
- 404 Media, “Proton pushes AI coding despite internal security concerns,” late October / early November 2026.
- Robert Haas, “PostgreSQL commit patterns and bug detection in 2026,” October 30, 2026.
- No Fluff Jobs, “Rynek pracy IT 2025/2026.”
- Just Join IT, “Co z tym Eldorado? 2024/2025.”
Related reading on this site:
- Universal Commerce Protocol service pillar
- Headless WordPress development
- WordPress security audit
- WordPress maintenance support
Last updated: 2026-11-02.
