Digging through portals and LinkedIn profiles is a total drag. That’s why we at ShiftMag launched a handy guide that packs the career ladders of major tech corps into one place! We already tackled Amazon, and today, Microsoft is on the menu!

To build this guide, I cross-referenced multiple sources: Microsoft’s official career site, Levels.fyi compensation data, LinkedIn profiles of current and former Microsoft engineers, and publicly reported industry data including salary leaks and engineering blogs.

Where sources conflicted, I noted the discrepancy rather than picking one arbitrarily. Compensation figures reflect self-reported U.S. data from Levels.fyi and should be treated as estimates, because they vary by location, team, and negotiation.

Microsoft’s engineering levels

In Microsoft, there are a number of standard job titles. Entry-level engineers start at L59–60 (SDE I) and progress through mid and senior roles up to L67–68 (Distinguished Engineer / Technical Fellow). The ladder splits into two tracks: management (Engineering Managers) and individual contributor (IC).

L59–60 – Software Engineer (SDE I)

Entry level for new graduates or engineers with under two years of experience. Engineers implement features, write and debug code on well-scoped tasks, and work under close mentorship. The primary focus is learning systems and coding practices.

L61–62 – Software Engineer II (SDE II)

Mid-level engineers with roughly 2-5 years of experience. They own more complex features end-to-end, write scalable code, and begin mentoring SDE Is. They influence design decisions within their projects but still receive technical guidance from seniors.

L63 – Senior Software Engineer (Senior SDE)

Engineers with approximately 5+ years of experience who own multiple features or projects and set technical direction within their domain. Senior SDEs lead design discussions, ensure long-term maintainability, and partner closely with product and engineering leads.

L64 – Principal Software Engineer

A senior IC role typically reached after 8-12 years of experience. Principal SDEs lead large components or entire technical domains, architect systems, and drive technical strategy. Some external sources label L64 as “Staff Engineer,” but Microsoft’s internal title is Principal SDE.

L65-66 – Principal Engineer II / Partner-Level

Principal-level engineers with broader organizational scope. These roles sometimes straddle IC and management tracks, with titles including Senior Principal or entry-level Architect. L65 is often where the formal “Principal” designation begins internally.

L67-68 – Distinguished Engineer / Technical Fellow

Top-tier IC roles focused on company-wide innovation and long-term technical strategy. Distinguished Engineers (L67) have deep domain impact across the organization. Technical Fellows (L68) are among the most senior technical positions at Microsoft and are extremely rare. These levels are not promoted into on a fixed timeline, they are typically nomination-based and require demonstrated impact at scale.

Cross-company level mapping

The table below shows rough equivalents across Google, Meta, Amazon, and Microsoft. These mappings are approximate – scope, expectations, and compensation vary significantly by company even at equivalent titles.

Compensation

Microsoft’s total compensation (base salary + bonus + RSU grants) rises steeply with each level. The figures below reflect U.S. median total compensation as reported on Levels.fyi. These change frequently and vary by location, team, and negotiation.

Compensation data sourced from Levels.fyi. Figures are self-reported estimates and should be treated accordingly.

A note on RSUs: Microsoft grants RSUs on a 4-year vesting schedule with a one-year cliff, after which shares vest quarterly. At senior levels (L63+), RSU grants make up an increasingly large share of total compensation – often exceeding base salary at L65 and above. Annual refresh grants are awarded through Microsoft’s performance review process (called “Connects”).

The post Microsoft Engineering Levels and Salaries: The Complete SDE Career Ladder (L59–L68) appeared first on ShiftMag.

In 2025, Sonar surveyed over 1.100 developers worldwide to see how software engineering is evolving. The findings show AI is now central to development – but it hasn’t made the job easier, only reshaped it.

Developers now write code faster than ever. At the same time, they spend more time questioning, reviewing, and validating what gets shipped. Productivity has increased. Confidence has not kept pace. This tension defines the current “State of Code” research.

AI is no longer experimental, it’s operational!

• 72% of developers who use AI coding tools rely on them daily
• Developers estimate that 42% of the code they commit is AI-assisted
• They expect that number to rise to 65% by 2027

AI-assisted coding has shifted from novelty to routine. Among developers who have tried AI tools, most now use them daily. Many estimate that more than 40% of the code they commit includes AI assistance. They expect that percentage to grow significantly in the next two years.

Developers use AI across the full spectrum of work: prototypes, internal tools, customer-facing products, and even business-critical systems. AI no longer supports side experiments. It participates directly in production workflows.

Instead of fighting the tool, rethink how you use it. How Uber engineers shifted from writing code with AI to assigning it work: a different approach to the productivity problem.

This level of integration signals a structural shift in software engineering. Teams no longer ask whether to use AI. They focus on how to use it responsibly.

Do developers trust AI?

• 58% use it in business-critical services
• 88% use AI for prototypes and proof-of-concept work
• 83% use it for internal production systems
• 73% integrate it into customer-facing applications

Developers consistently report that AI makes them faster. Most say AI helps them solve problems more efficiently and reduces time spent on repetitive tasks. Many even report increased job satisfaction because they can offload boilerplate and mechanical work.

However, speed does not equal certainty. Nearly all developers (96%) express doubts about the reliability of AI-generated code. They acknowledge that AI often produces output that looks correct at first glance but contains subtle errors or hidden flaws. This creates a trust deficit.

Despite this skepticism, not all developers consistently verify AI output before committing it. The pressure to ship features quickly often outweighs the discipline of thorough review. As a result, teams face a new bottleneck: verification.

Reviewing AI-generated code frequently demands more effort than reviewing human-written code. Developers must reconstruct intent, validate assumptions, and check edge cases without knowing how the model arrived at its solution. AI compresses the time spent writing code but expands the time required to evaluate it.

In this environment, confidence – not velocity – becomes the true measure of engineering maturity.

AI doesn’t remove toil, it changes it!

75% believe AI reduces toil. However, time allocation data reveals a more complex picture:

• Developers still spend roughly 23–25% of their work week on low-value or repetitive tasks
• This percentage remains consistent regardless of AI usage frequency

One of the promises of AI tools involved reducing developer toil: repetitive, frustrating tasks such as writing documentation, generating tests, or navigating poorly structured codebases. Many developers believe AI reduces certain kinds of toil. They report improvements in documentation quality, test coverage, and refactoring efficiency.

However, the overall proportion of time developers spend on low-value work has not meaningfully decreased. Instead, AI shifts the nature of toil. Developers now spend less time writing boilerplate and more time validating AI suggestions. They spend less time drafting documentation and more time correcting generated code. Traditional frustrations have not disappeared; they have transformed.

This dynamic challenges simplistic narratives about AI productivity gains. AI does not eliminate friction. It redistributes it.

Teams that recognize this reality can adapt workflows accordingly. Teams that assume AI automatically saves time risk underestimating the verification cost.

Technical debt: reduction and acceleration at once

Positive impact:

• 93% report at least one improvement related to technical debt
• 57% see better documentation
• 53% report improved testing or debugging
• Nearly half report easier refactoring

Negative impact:

• 88% report at least one negative consequence
• 53% say AI generates code that appears correct but is unreliable
• 40% say it produces unnecessary or duplicative code

AI influences technical debt in both directions. On the positive side, developers use AI to modernize legacy code, generate missing tests, improve documentation, and refactor inefficient structures. These activities reduce long-standing debt and improve maintainability.

On the negative side, AI sometimes generates redundant, overly verbose, or structurally weak code. Developers frequently encounter code that appears correct but introduces subtle reliability problems. When teams integrate such code without rigorous review, they create new debt.

AI therefore acts as both a debt reducer and a debt accelerator. Managing this tension requires deliberate governance. Teams must treat AI contributions as first-class code changes subject to the same standards as human-written code. Automated testing, static analysis, and clear architectural principles become even more critical in this environment.

Technical debt already ranks among developers’ top frustrations. Uncontrolled AI usage can amplify that burden rather than alleviate it.

What is shadow AI?

Most used tools:

• GitHub Copilot (75%)
• ChatGPT (74%)
• Claude (48%)
• Google Codey/Duet (37%)
• Cursor (31%)

GitHub Copilot and ChatGPT dominate AI-assisted coding usage, but developers rely on a growing ecosystem of tools. Many teams use multiple AI platforms simultaneously, selecting each for specific strengths. This fragmentation creates flexibility but introduces complexity.

A critical risk signal:

• 35% of developers use AI tools through personal accounts
• 52% of ChatGPT users access it outside company-managed environments
• 57% worry about exposing sensitive data

Developers often access AI tools through personal accounts rather than company-approved environments. This behavior reflects demand for productivity but introduces governance risks. When developers paste proprietary code into unmanaged AI systems, organizations lose visibility and control.

Security concerns rank among the most significant worries associated with AI adoption. Developers themselves recognize the risk of exposing sensitive data.

Organizations must respond pragmatically. Banning AI rarely works. Developers adopt tools that help them work faster. Instead, companies should provide secure, sanctioned AI environments and define clear usage guidelines. Enablement, not prohibition, produces safer outcomes.

The experience divide

Less experienced developers:

• Use AI for understanding codebases
• Rely more heavily on AI for implementation
• Estimate a higher percentage of AI-assisted code

Senior developers:

• Use AI more selectively
• Focus on review, optimization, and refactoring
• Express higher skepticism

AI does not affect all developers equally. Less-experienced developers tend to adopt new AI tools more aggressively. They use AI to understand unfamiliar codebases, generate implementations, and explore new frameworks. For them, AI functions as both assistant and tutor.

More experienced developers integrate AI differently. They rely on it to review code, optimize performance, and assist with maintenance tasks. Their experience enables them to identify flaws more quickly and apply AI selectively.

Junior developers often trust AI more readily. Senior developers approach it more cautiously. This difference does not reflect competence; it reflects perspective.

High-performing teams combine both approaches. Junior engineers introduce experimentation and speed. Senior engineers provide oversight and architectural discipline. Together, they mitigate risk while capturing gains.

What this means for engineering teams?

The State of Code 2025 reveals a profession in transition. AI increases output but raises the bar for validation. It reduces certain manual burdens while introducing new forms of cognitive load. It offers opportunities to address legacy debt while risking new complexity.

The central lesson does not concern speed. It concerns confidence. Developers must treat AI as a powerful collaborator that requires supervision. Engineering leaders must invest in testing infrastructure, review practices, and secure tooling environments. Organizations must acknowledge that productivity improvements depend on disciplined integration, not blind adoption.

Developers no longer compete on how quickly they can type code. They compete on how effectively they can evaluate, refine, and ship trustworthy systems.

The tools have changed. The responsibility has not. Teams that focus on clarity, code quality, and secure AI integration will thrive in this new environment. Teams that chase velocity without verification will accumulate invisible risk.

The post 42% of Code Is Now AI-Assisted! appeared first on ShiftMag.

At the Web Summit conference, Andrew Filev, CEO of Zencoder – a company that achieved a $2.25B exit – debunked that myth. He called it blind hustle, a mindset that destroys long-term innovation and sustainable growth.

For engineers and founders navigating fierce competition, Filev argues that success depends not on the number of hours worked but on the quality, focus, and sustainability of effort. He calls this approach the smart grind.

The toxic cult of 996

Filev highlights how overwork has become normalized, especially through the infamous “996” schedule, 9 AM to 9 PM, 6 days a week, a routine common in hyper-competitive tech markets.

This panic-driven culture often disguises itself as passion but ultimately stunts professional growth.

Creative output peaks only within a certain range; beyond that, productivity nosedives. Those extra hours often add little value and instead drain the energy needed for rest, reflection, and strategic thinking.

Many skilled engineers fall into what Filev calls the “over-engineer’s trap,” where they chase hours instead of impact. In doing so, they trade clear, strategic thinking for the illusion of productivity, creating overly complex solutions when simpler ones would suffice.

Even stepping away can feel difficult. Filev recalls taking vacations yet constantly feeling pulled back into work, a cycle that slowly erodes creativity. Innovation, he argues, depends on perspective – and perspective only comes when you truly disconnect.

The “smart grind” mindset

Instead of chasing blind hustle, Filev promotes the smart grind, which drives lasting, industry-defining success.

The myth of the “overnight success” fuels burnout. Filev explains that every transformative company, including his own, grew from years of consistent, intentional work. Real progress demands a sustainable pace, not a desperate sprint.

I’d rather work in a way that increases the law of probability that success finds me.

True success isn’t a lottery. It’s the outcome of steady, high-quality decisions that compound over time.

Think clearly and direct AI effectively!

Shift your focus from how long you work to what you work on and how you approach it.

Start by recognizing patterns, study market trends, and your team’s performance to make smarter, more informed choices.

Then, guide your direction by ensuring every hour of effort supports your long-term strategy instead of reacting to short-term, low-impact tasks.

Filev warns that AI could amplify the blind hustle mindset. As automation handles more tasks, the real advantage belongs to people who can think clearly and direct AI effectively. Burnout dulls that ability, leaving even talented teams ineffective as AI “bosses.”

The edge no longer comes from working longer, but from maintaining the mental clarity to make high-impact, strategic decisions. Filev’s message is simple:

The $2.25B exit didn’t come from sleepless nights at the office. It came from years of disciplined, well-rested, high-quality decisions. True innovation and lasting success come from sustainability, not sacrifice.

The post Zencoder CEO: Hustle Hype Didn’t Drive Our $2B Exit – Sustainable Work Did appeared first on ShiftMag.

As technology accelerates, the way we build and deploy applications is transforming at its core. Leading that transformation is Dana, who has guided engineering teams through major transitions at GitHub, Heptio, and now Netlify.

In our conversation, she shared her vision for the future of web development and what engineers will need to succeed in the next few years.

The composable, agent-driven future

Lawson sees the future of web architecture moving decisively toward composability and automation-driven responsiveness. She highlights three trends that will redefine development over the next three to five years.

First, companies are dismantling monolithic applications in favor of micro-frontends. Teams now design for both human users and AI agents, forcing them to rethink performance from the ground up.

Second, composable architecture is taking hold, a headless, microservice-inspired approach that makes systems extensible and resilient:

The goal is easy extensibility, because we genuinely don’t know what’s coming next.

The third, and most disruptive, shift centers on how data gets consumed. AI agents, not humans, are calling APIs, which drives an intense need for speed. Edge computing, caching, and edge-first rendering are no longer best practices; they are now baseline requirements.

Scale your team with trust, not bureaucracy

To meet these new technical demands, engineering leaders must rethink how they scale teams. Lawson argues that traditional models like Spotify’s are giving way to leaner, flatter organizations.

“The expectation is that individuals in tech can now do more,” she says. This shift favors teams with fewer layers of management, broader spans of control, and higher autonomy. To sustain velocity and creativity, Lawson emphasizes three cultural pillars:

• Adopt a growth mindset and integrate AI tools into daily workflows.
• Develop design sensibility, what Lawson calls “taste,” as engineers move toward live, one-click prototyping.
• Maintain alignment across horizontal teams, since less bureaucracy means coordination becomes both harder and more crucial.

Does the full-stack developer still exist?

As complexity spreads across the frontend, backend, and edge, many question whether the “full-stack developer” still exists. Lawson insists the role is not obsolete; it is evolving.

“Agents have now unlocked us to be truly full-stack,” she explains. Developers can master one domain and rely on AI to fill gaps in another, removing the friction of cross-team handoffs.

Lawson compares this moment to the rise of DevOps:

It’s the same premise. Twenty-six years ago, SysAdmins felt threatened by DevOps. It evolved, and now we’re one step further. Developers are gaining even more control of their systems.

In her view, the developer role is not disappearing – it is expanding. As barriers to entry drop, citizen developers such as PMs, designers, and entrepreneurs are joining the ranks. Professional engineers must adapt, sharpening their skills and embracing the new, AI-augmented workflow.

Agents can do the work, but humans still run the show

Even with smarter tools and modular architectures, Lawson sees one major challenge left: closing the “last mile” of getting an idea online.

Modern coding tools have simplified development, but deployment and management still demand effort, especially from new developers. As companies introduce AI into their pipelines, Lawson advises them to apply the same security and compliance guardrails used during the DevOps revolution.

You want to make sure you’re not leaking data or secrets, and that you’re not trusting agents blindly.

Teams need transparent documentation, well-defined context files, and clear rules for how code moves through the development lifecycle.

For Lawson, the next generation of technologists must focus as much on soft skills as on code. As agents take over more execution, human collaboration becomes the differentiator. She encourages young developers to lean into teamwork, communication, and empathy, skills that will define success in an increasingly horizontal industry.

The post Unlock Your True Full-Stack Potential with AI Agents appeared first on ShiftMag.

Krešo Žmak, VP of Products at Infobip, held a roundtable on the first day, just before the conference opening, on the topic: From SaaS to Agents: How Personal AI Will Redefine Platforms and User Experience.

To bring you firsthand insights on this topic, we spoke with Krešo. In the interview that follows, you’ll learn everything you need to know about how AI will transform software-as-a-service as we know it and make the user experience truly extraordinary.

Why data is the key barrier to AI-powered platforms?

Krešo Žmak identified data as the biggest technical barrier in transitioning from a traditional SaaS model to agent-driven platforms.

“The biggest challenge lies in the data,” he said. “It involves combining different sources, managing access, hierarchy, structure, governance, availability, throughput, and so on, because AI is all about data.”

He contrasted deployment speed with real productivity:

You can deploy an agent in minutes by writing a prompt. That’s the initial step. But the real struggle begins when you try to make the agent productive. The first obstacle you face is how to access the data.

Even with modern tools, the issue remains that MCPs simplify access to backend and legacy systems, but the data behind those MCPs or APIs often stays unstructured and undocumented, which creates the biggest challenge.

Architecting CPaaS for the agent-to-agent world

Krešo emphasized that AI “heavily affects the software industry”. He explained that CPaaS architectures must evolve without requiring a complete redesign.

“In the short to mid term, channels will remain the primary way of communication,” he said, “because business agents will continue to interact with end users”.

He emphasized the need for CPaaS platforms to introduce new interfaces that support agentic capabilities – such as MCP or agent-to-agent connections – to integrate agentic solutions directly into the CPaaS stack. In his view, MCP adoption is already increasing significantly compared with legacy API integrations.

Krešo described the long-term paradigm shift:

In the future, brands and end users will communicate through agents talking with personal agents. Communication will move from machine-to-person to machine-to-machine.

He predicted this revolution will become mainstream by 2028, though rapid AI innovation could accelerate it to next year.

Modern AI products can’t skip MCPs or agent talk

Krešo highlighted MCP and agent-to-agent interfaces as mandatory technologies for modern AI-first products.

CPaaS companies must expose APIs through MCP interfaces and build agents that handle parts of the CPaaS workload, such as onboarding, analytics, or messaging.

He clearly described this transition as the future, where agents will communicate with other CPaaS agents or consume MCP interfaces. This shift is already reshaping the CPaaS landscape.

LLMs need infrastructure to be reliable

Furthermore, Krešo argued that the core problem with LLMs doesn’t lie in the technology itself but in how people use it, particularly when it comes to hallucinations.

He explained that if you rely on an LLM directly, it will hallucinate and produce incorrect answers. He advised enterprises to build infrastructure around LLMs:

You need to wrap LLMs with RAG pipelines, enforce guardrails, and process outputs to check for compliance. You must anchor the LLM to the context it serves. An enterprise solution should only respond within the brand’s context.

Finally, he noted that LLMs require integration because an LLM cannot execute actions on its own. To make it useful, you must connect it to the enterprise backend system.

The future of software is a hybrid “chat-with-your-app” model

Krešo confirmed the rise of the “chatting with software” paradigm in modern user experience design. He explained that users increasingly activate services, check analytics, or launch campaigns by typing prompts or interacting conversationally with interfaces.

He predicted a hybrid model in which non-deterministic LLM interactions are paired with deterministic UI elements. Inside a portal, users may chat to trigger actions while still receiving structured analytical graphs and predictable outputs.

The future lies in combining classical web interfaces, UIs, and prompting to enhance capabilities.

AI-powered personalization means knowing users inside out

Krešo explained that AI significantly augments and accelerates business processes and provides much greater capability for processing and structuring data, which drives personalization. He clarified that true personalization is not about surface-level details but about understanding the full context of a user’s interaction, whether they are reaching out about a campaign, an invoice, or something entirely different.

He added that AI enables the summarization of large volumes of data by connecting various touchpoints between a brand and a user and turning them into meaningful insight far beyond classical personalization models.

Personalization means knowing the full context of the user, not just who they are.

Strong engineering fundamentals are crucial

Krešo urged developer teams to focus on core engineering knowledge rather than transient AI tools. He emphasized the importance of architectural skills:

Understanding design principles and architecture will become increasingly important. Developers must know how to build applications, how data connects to the user interface, and how the backend processes it.

He concluded that AI tools can accelerate development, but only engineers with strong fundamentals can use them to build robust solutions quickly.

The post How AI Agents Are Changing the Way Developers Build Software appeared first on ShiftMag.

At Web Summit 2025, Mozilla CEO Laura Chambers and Cloudflare CEO Matthew Prince joined Mike Butcher from PathFounders to dissect this transition.

Their conversation revealed a stark reality – the way we consume information is fundamentally changing, and without new rules, the economic model of the internet could collapse. As Chambers put it, we must ensure “the web doesn’t become siloed or closed off” during this massive shift.

Welcome to the new web where AI browses and we chill

For decades, a browser acted as a simple container. You typed a URL, the browser fetched the content, and you read it. Chambers argues that this era is ending:

I think we’re moving from a world where browsers are simple containers. We are entering a phase of agentic activity where “the browser, or the AI agent inside it, takes action on our behalf.”

Prince views this as a massive platform shift, comparable to the transition from desktop to mobile. He predicts that in the near future, personal AI agents will handle the majority of information retrieval and commerce.

While this promises efficiency, it fundamentally breaks the relationship between creators and consumers. “AI is the next platform shift,” Prince stated. “In the future, the way people interact with information will be through their personal AI agent.”

Houston, we’ve got a “vampire bot” problem

The most immediate danger lies in how AI browsers interact with publishers. Prince highlighted a growing trend where AI agents overstep boundaries. A user might ask an AI browser to read one article from The New York Times. The agent visits the site to fulfill the request but acts aggressively. Prince described the behavior:

They’ll read the specific article the user asked for but then they’ll also scrape everything published on that site that day.

This behavior undermines the business model of journalism. Publishers rely on human traffic, subscriptions, and ad impressions. If an AI scrapes the content and summarizes it for the user, the original creator receives zero value. Prince warns that if AI companies consume content without contributing to the ecosystem, they will destroy the very data sources they need to survive. “If AI scrapes everything behind the paywall and redistributes it,” Prince warned, “the entire system breaks.”

Matthew Prince, Co-founder & CEO, Cloudflare; Mike Butcher, Founder and Editor, Pathfounders; Laura Chambers, CEO, Mozilla, backstage on centre stage during day three of Web Summit 2025 at the MEO Arena in Lisbon, Portugal. Photo by Shauna Clinton/Web Summit via Sportsfile.

Users put privacy first, don’t they?

Users claim to value privacy, yet they almost always choose convenience. Chambers noted that while Mozilla builds privacy-by-design into Firefox, the average user prioritizes a frictionless experience over data protection:

Unfortunately, what we typically see is that users choose convenience. They choose simplicity over privacy even when they say they value privacy.

This creates a dangerous feedback loop. If the most convenient AI tools are also the most invasive, users will surrender their data without a second thought. Chambers believes the solution lies in “optionality.” Browsers must allow users to choose between a classic, private experience and an AI-enhanced one.

However, Prince suggests that users no longer care about original sources. Data from Cloudflare shows a sharp decline in click-through rates for users of AI tools like Anthropic and OpenAI. “Younger users especially aren’t opening 10 blue links,” Prince noted. “They want the answer, not the process.” The “ten blue links” of a Google search are becoming artifacts of the past.

The browser can act as a trusted middleman

If users demand AI, how do we protect privacy? Prince proposed a novel role for independent browsers like Firefox. He argues that the browser should act as a trusted intermediary between the user and the AI model:

I want to type something into a trusted intermediary, and have it figure things out.

In this scenario, the browser holds the user’s context and memory. When a user asks a question, the browser anonymizes the data, converts it into mathematical vectors, and sends it to the best available model (whether that is OpenAI, Gemini, or Anthropic). The AI provider receives the math needed to answer the query but never learns the user’s identity. “You can encode that as math,” Prince explained, noting that the data becomes “irreversible but meaningful enough for the model to do its job.”

This approach positions organizations like Mozilla and Apple as vital gatekeepers. They can verify that a request comes from a real human without revealing who that human is. This “proof of humanity” will become the most valuable currency on an internet flooded with bots.

The “click” is dying

The current trajectory of the web favors a monopoly where one or two AI giants control all information flow. Both CEOs agree that this is a dystopian outcome. A healthy internet requires diversity, where small businesses and independent publishers can still thrive. “A good future isn’t one with only five AI companies,” Prince declared. “It’s one with tens of thousands.”

Cloudflare intends to enforce rules that penalize bad actors who scrape content aggressively. Meanwhile, Mozilla continues to maintain its own engine, Gecko, to ensure that commercial interests do not solely dictate web standards. Chambers insisted:

We need the voice of the people represented in these conversations

The business model of the internet is about to change. The “click” is dying. The challenge for the next five years is to invent a new economic system that rewards creators in an age where AI answers every question. If we fail to do so, the open web may simply disappear inside a chatbot’s dialogue box. As Prince concluded, “We must find a way for publishers to continue earning revenue.”

The post Bye-Bye Clicks! AI Agents Are Running the Web Now appeared first on ShiftMag.

At the recent Web Summit, Cristóbal Valenzuela (founder and CEO, Runway), argued that World Models – AI systems trained to understand and predict the physical rules of our universe – represent the next major leap. He described them as a “new kind of camera” for reality.

For developers, this shift represents more than a model upgrade. It opens entirely new classes of applications, moving from simple content generation to real-time, interactive simulation.

World Models let AI understand and predict reality

Valenzuela traces a clear progression in generative AI. First, photography and language models (LLMs) act as tools that represent or abstract reality, with language models capturing patterns in human communication, essentially a human-created abstraction of the world.

Next, video generation models, such as Gen-1 and Gen-2, produce contiguous visual narratives, initially focused on storytelling and entertainment. These models maintain temporal consistency but primarily operate on the visual surface.

Finally, world models go further by training not only on pixels and text but also on the principles of physical reality, 3D geometry, and cause-and-effect. They learn how the world behaves and can predict actions and consequences within a simulated space.

Just as we humans mentally model the trajectory of a falling object after observing gravity, World Models develop their own mental model of the physical world. They train on diverse inputs (video, images, text, and natural observations) to capture reality’s complexity without relying solely on language.

New Verticals and Real-Time Experiences

Shifting to models that simulate entire worlds instead of generating single scenes affects developers in several ways:

Real-Time Interactive Experiences

World Models enable real-time inference, moving Generative AI from the render queue into live applications. Developers can generate non-linear, interactive game worlds on the fly, creating emergent gameplay instead of pre-scripted narratives. Educational content, tours, and product demos can adapt in real-time to a user’s query and context, with the pixel stream generated dynamically rather than pre-recorded.

Revolutionizing Robotics and Data Collection

AI for robotics and autonomous systems often stalls at data acquisition. World Models create synthetic training data, simulating scenarios that would take terabytes of real-world footage to capture. Robots can “watch and learn” in rare edge cases or complex environments without expensive, time-consuming data collection.

New Workflow Paradigms

Content creators will shift from editing to prompting reality. Tools like Runway’s Gen-4 already improve narrative consistency across scenes, paving the way for full World Models. Developers must move from rigid pipelines to flexible, generative workflows, letting models handle physics, lighting, and consistency based on high-level direction.

The main technical hurdle remains compute capacity

Valenzuela believes early forms of World Models are “here today” and expects major improvements in consistency and inference speed over the next 12–18 months.

The main technical hurdle remains compute capacity. Generating fully consistent, interactive worlds in real-time demands immense GPU power, requiring optimized code and efficient resource allocation.

For developers, the challenge goes beyond technology. They must embrace a new paradigm and build applications where pixels emerge from the model’s understanding of physics, not static assets.

The post World Models Are the Next Big Leap in AI appeared first on ShiftMag.

Roland Liposinović, Security Governance Generalist at Infobip, sees a critical shift: security should no longer be an afterthought or a compliance checkbox:

Make security a growth tool, not a tax. Build safety in from day one, and audits finish faster, big customers say yes sooner, and purchasing roadblocks disappear.

This mindset shift is one many organizations still struggle to make.

Too often, security is treated as a necessary evil, something to appease auditors and regulators. But Roland argues that security-first development is a competitive differentiator. By integrating controls early, companies can unlock new markets more quickly, shorten sales cycles, and establish trust in ways that directly impact the bottom line.

Security isn’t red tape. It’s quality control for modern, AI-powered products. Trust drives sales. Secure design grows trust over time.

Embed security across the entire development lifecycle

The question, then, is how to embed these practices across the entire software development lifecycle, from planning and coding to testing, deployment, and operations, without slowing down AI-driven innovation.

Roland’s answer is to make security invisible, automated, and developer-friendly.

“Think automatic seatbelts, not checklists,” he says. At Infobip, the team embeds rules directly into their cloud setup and delivery pipelines, ensuring that “the safe way happens by default.” Automated checks scan for vulnerabilities, exposed secrets, risky dependencies, and unvetted model files every time developers save code. If something is off, the build fails fast with clear feedback.

Feedback should arrive in minutes while developers are still working, not days later. Security runs next to the team, not in front of it, blocking the door.

One additional thing you can do before major projects is run lightweight risk assessments focused on a few key questions: How could this feature be misused or abused? What data does it touch? Who could misuse it? This practice, repeated whenever something changes, enables threat modeling to remain fast and continuous.

When it comes to testing, you should test like attackers would. “We throw malicious prompts, poisoned data, and guardrail-breaking attempts at our AI systems before release,” he says. “If our AI misbehaves, we fix it before anyone else can exploit it.”

Make it zero-trust!

AI helps defenders, but it also helps attackers. Adaptive phishing, deepfakes, and model inversion attacks are no longer hypothetical – they’re real. Roland advocates for a layered defense strategy that combines privacy-preserving techniques, governance frameworks, and culture change.

For model inversion, he points to regularization techniques, API access controls, and specialized defenses such as trapdoors to misdirect attackers.

However, data discipline matters just as much: teams minimize personal data, de-duplicate records, and apply strong consent and retention policies before training models. On the human side, Roland is blunt:

Make it zero-trust. Strong login, least privilege, and constant verification for people, services, and AI models.

His team conducts frequent, audience-tailored awareness sessions and real-world drills, ranging from deepfake scenarios to phishing simulations, so that employees can recognize emerging threats.

Strict communication rules help as well: sensitive actions like payments, access changes, and data requests must go through verified channels with two-person approval, never via informal messages or DMs.

If a request is urgent and secret, slow down. We give staff explicit cover to pause and verify even if it is “the CEO” on the line.

Security isn’t a cost center – it’s a revenue enabler

Roland emphasizes measurement as the bridge between technical controls and leadership buy-in. He recommends tracking metrics such as time to close deals, incident rates, audit duration, and verification rates before taking high-risk actions. Mapping controls to established frameworks, such as CIS Controls v8, NIST 800-53, and ISO 27001/27002, streamlines audits and makes funding more defensible.

When you can prove that certifications and clear proof of controls shorten sales cycles and open partnerships, suddenly security isn’t just a cost center. It’s a revenue enabler.

Treat the pipeline like production

As AI accelerates software delivery, the CI/CD pipeline has become the beating heart of modern development, but it has also become an increasingly attractive target for attackers. Roland warns that organizations can’t afford to treat their delivery pipelines as second-class citizens.

Treat the pipeline like production. It runs the factory, protect it like crown jewels.

Securing automated delivery flows starts with proof, not trust. Only signed code, images, and models are allowed through. “If it isn’t signed, it doesn’t ship,” he emphasizes. The system automatically scans dependencies, containers, secrets, and cloud configurations, and it halts the build immediately when it finds critical issues.

Teams isolate access using short-lived tokens and separate runners, eliminating the need for “kubectl from a laptop” shortcuts. The pipelines themselves are under constant surveillance.

Alert on strange runner behavior or workflow changes. If something looks off, pause and investigate before it spreads.

Track behavior, not just components

This rigor extends beyond internal code. As AI ecosystems grow more interconnected, the supply chain, spanning third-party libraries, pretrained models, datasets, and vendors, has become a prime target for sophisticated attacks. Roland advocates for a “trust, but verify” posture.

Track what’s inside. Ship an SBOM with every release, apps, containers, and model bundles, so you know every ingredient.

Teams must sign and verify every artifact, from model files to data packages, before using it. Teams don’t take third-party components at face value; they vet vendors for lineage, update habits, and incident history, and they require formal attestations.

Pretrained or open-source models are quarantined by default until they are scanned, wrapped, and continuously monitored for security vulnerabilities. Once the system is in production, teams can track behavior in real-time.

Don’t just list components, watch what they actually do.

Classify your AI by risk

With the EU AI Act and new data protection laws reshaping the regulatory landscape, Roland sees compliance not as a scramble at launch but as an architectural principle.

Design for the EU AI Act and friends from day one. Classify your AI by risk, attach the right controls, and plan human oversight where it is required.

This regulatory-first mindset drives concrete engineering practices: teams bake data minimization and purpose limitation into schemas and pipelines, not just policy documents. Model cards, decision logs, and clear appeal paths make AI decision-making explainable for both auditors and end users. Teams maintain immutable logs and model lineage with retention policies that align with legal obligations.

Be audit-ready, always. It’s much cheaper than retrofitting compliance later.

Get all signals in one place

As attackers adapt their tactics in real time using AI, defensive strategies must also become equally dynamic. Roland emphasizes the importance of observability, telemetry, and AI-driven defense in detecting anomalies before they escalate.

“Get all signals in one place,” he says. Teams aggregate logs from endpoints, identity systems, APIs, data jobs, and models into a single observability layer. Crucially, security teams monitor not just applications but the models themselves, tracking drift, unsafe outputs, and suspicious prompt behavior.

Detection should be trained on your own operational environment rather than generic threat baselines, so anomalies stand out quickly. When something triggers, automated playbooks in SOAR systems can take immediate action: isolating systems, rotating secrets, revoking tokens, or rolling back versions within minutes.

You can’t wait for a human ticket queue when the attack is adapting on the fly.

Make security a team habit

For all the technology and governance, Roland insists that the real force multiplier is culture. Security can’t live in a silo, it has to become a team habit.

Plant security champions in every squad. Peer-to-peer help beats one central bottleneck.

Regular tabletop exercises tied to real-world projects, such as handling deepfake scams, leaked credentials, or prompt injection attacks, keep teams alert and well-practiced.

Teams can also use positive reinforcement: they can celebrate clean audits, sharp threat models, and early bug catches publicly. To make good behavior the default, Infobip provides “paved roads,” opinionated templates, and secure defaults that make the safe path the easiest one.

With these layered strategies Roland is helping redefine what “secure AI” looks like in practice.

Security isn’t a brake on innovation. It’s what lets you innovate safely and keep that advantage.

The post Want Better Security? Test Like Attackers Would appeared first on ShiftMag.

Imagine an AI agent tasked with booking a flight, informing the user of the details, and setting up a 2FA notification for their departure. This isn’t science fiction anymore.

For such an agent to succeed, it must interact with airline APIs, messaging platforms, and potentially a customer data platform. The challenge, as Filip highlighted, is standardizing these interactions – creating a universal language that allows AI to “speak” with the tools it needs.

Good communication for AI agents requires rules and engagement

Filip opened his talk with a deceptively simple question: What makes communication effective?

His answer – rules and engagement – strikes a chord not just for human interaction, but for AI agents as well. Just as people rely on shared protocols (language, social cues, context) to connect and collaborate, AI agents need structured ways to exchange messages, understand context, and work toward common goals.

This isn’t about giving AI a personality, it’s about building a solid framework for it to operate within.

With its vast global communication network, Infobip is uniquely equipped to provide that framework. From managing sender registration and channel-specific rules to handling intelligent message routing and fraud detection, Infobip takes care of the complexities, allowing developers to focus on the core logic of their AI agents.

MCP is the USB-C for AI applications

At the heart of Infobip’s solution is the Model Context Protocol (MCP). In the original MCP specification, it’s described as being similar to a “USB-C port for AI applications”. It’s an open protocol that standardizes how applications provide context to AI models, enabling them to connect seamlessly with diverse data sources and tools. This is a game-changer for several reasons:

• Interoperability: MCP allows developers to switch between different AI providers and vendors without re-architecting their entire communication layer. This fosters a more open and competitive AI ecosystem.
• Contextual Understanding: By standardizing the flow of “tools, resources, and prompts,” MCP ensures that AI models receive the necessary context to understand requests and execute tasks accurately.
• Communication Superpowers: With Infobip MCP servers, AI agents don’t just chat – they communicate. They can exchange rich content like images, not just text, and seamlessly interact across multiple channels. In short, Infobip MCP gives AI agents true communication superpowers. They gain the ability to:

1. Send messages via SMS, WhatsApp, Viber, RCS – critical for reaching users on their preferred channels.
2. Set up and manage two-factor authentication (2FA), adding a vital layer of security.
3. Access customer data platforms: With Infobip’s People platform – Customer Data Platform – AI agents gain access to rich customer insights. They can personalize every message, every response, and every interaction
4. Manage user accounts and explore Infobip documentation to enable self-sufficiency for specific tasks.

OpenAPI enables dynamic MCPs, but design drives experience

One of the core architectural principles underpinning Infobip’s MCP servers is their reliance on the OpenAPI Specification. This community-driven, open standard for describing HTTP APIs is a perfect fit for MCP’s needs. Filip explained:

Think of the OpenAPI specification like a standardized, both human and machine-readable, API reference.

This isn’t just about documentation; it’s about enabling auto-generation and auto-discovery. The Infobip MCP servers can dynamically understand and interact with available API endpoints based on their OpenAPI descriptions. This means:

• Dynamic Tooling: An MCP tool directly corresponds to an OpenAPI operation. This 1:1 mapping allows the MCP server to dynamically perform necessary API calls based on the AI agent’s request.
• Scalability: The ability to dynamically discover and connect to APIs enables MCP servers to be deployed at scale, adapting to ever-changing service landscapes without requiring manual configuration updates. This is crucial for building resilient and adaptable AI agent ecosystems.

However, Filip emphasized a critical point:

Carefully select API endpoints to expose. Rebuild your API to match the AX (Agentic Experience) you want to achieve.

This isn’t a magic bullet; it requires thoughtful API design to optimize the agentic experience.

Challenges and solutions

While the vision is clear, the path isn’t without its technical challenges. Filip explored some of these, offering insights into how Infobip is tackling them:

• Input JSON Schema Resolution: OpenAPI’s JSON Schema vocabulary isn’t entirely congruent with the broader JSON Schema Specification. This can lead to complexities in resolving input schemas for AI agents.
• OpenAPI Discriminators: Discriminators, which define type-based polymorphism, are helpful for server-side validation. However, for input schema matching, they can be flattened into a oneOf schema, simplifying the interpretation for AI agents. This involves transforming a structure that hints at expected schemas based on a property value into a more direct enumeration of possible schemas.
• Reference Resolution: Unlike OpenAPI, MCP doesn’t inherently provide schema storage. This means reference resolution can lead to complex nested schemas. The solution, again, lies in intelligent API design: “It is our responsibility to design the underlying API to achieve the right Agentic Experience.”
• Authentication: Infobip MCP servers act as a secure proxy – a core part of our architecture – leveraging downstream platform authentication mechanisms. Robust authentication middleware verifies credentials and safely propagates them, while OAuth support through metadata discovery endpoint proxies ensures seamless, secure integration.

The Future is Agentic

The implications of Infobip’s work with MCP servers are profound. By abstracting away the complexities of diverse communication channels and standardizing interactions with external tools, they are laying the groundwork for a new generation of AI agents. These agents won’t just respond; they will act, communicate, and integrate seamlessly into our digital lives.

Developers now have a reference implementation and a clear path to begin building their own communication-powered AI agents. As AI continues to evolve, the ability of agents to communicate effectively will be paramount.

Infobip, with its MCP servers, isn’t just facilitating this communication, it’s providing the essential infrastructure for AI to truly unlock its agentic capabilities and reshape how we interact with technology. A real-world example of this is the Autorun.ai integration, developed in partnership with the Croatian startup Rearm, showcasing how Infobip MCP powers next-generation AI solutions in practice.

Explore the Infobip MCP servers to see this in action or use the open-source Infobip OpenAPI MCP framework to expose your own OpenAPI-described services to AI agents. 

Want to know what else was discussed at Infobip Shift at Zadar in 2025? Find out here!

The post How Infobip’s MCP Servers Enable Smarter AI Communication appeared first on ShiftMag.

The reality, he argued, is somewhere in the middle. He introduced a five-level framework for automation in software development, drawing inspiration from the levels of autonomy in self-driving cars.

Level 1

At Level 1, AI acts as a smart autocomplete. It suggests code snippets and fixes basic syntax errors, offering help that feels familiar. While helpful, it does not understand a company’s unique codebase or specific frameworks.

Level 2

Things get more interesting at Level 2, the “Junior Software Agent” stage. At this level, AI agents can go beyond simple syntax. They interact with compilers, run tests, and use feedback to debug and improve their code. They aren’t perfect, often getting stuck in repetitive loops or “hallucinating” incorrect code.

Level 3

The real power lies in Level 3: Multi-Agent Systems. Multiple AI agents collaborate here to solve complex problems, much like a human team. They can assign tasks, reflect on each other’s work, and provide feedback.

Alex showcased a live demo in which a team of agents—a product manager, front-end developer, back-end developer, and DevOps—worked together to build and deploy a simple conference website. The agents completed a multi-step task with only a five-line prompt from the user.

At the Infobip Shift conference in Zadar, Alex delivered a talk titled “Will AI (Finally) Replace Developers?”

Level 4

Moving on, Level 4 involves Production-Ready Agents. These agents integrate seamlessly across the entire software development lifecycle — from writing code to managing deployments and continuous integration. The human developer’s role shifts from writing every line of code to supervising and managing these agents.

Level 5

At Level 5, we find Full Autonomy. At this theoretical level, the AI is entirely self-sufficient. A developer would simply give a high-level command like “Build me a social media platform,” and the AI would handle every process step.

While this level is still a ways off, Alex noted that the rapid pace of AI development suggests it’s no longer a far-off dream.

Developers with AI will Replace Developers without AI

The core message is clear: developers won’t be replaced by AI, but by other developers who know how to use AI. The future of software development isn’t a human-versus-machine battle but a new kind of collaboration.

The developer’s role will evolve from hands-on coder to project manager or “orchestrator” of an army of AI agents. Instead of spending hours on repetitive tasks, developers can focus on higher-level problem-solving, system architecture, and complex challenges that require a human touch. This shift mirrors historical industrial transformations.

The invention of the car didn’t eliminate all jobs in transportation — it created new ones like car manufacturing and maintenance. Similarly, AI will transform development. We’ll still need developers to design, debug, and manage these systems, but the nature of the work will change.

Alex ended on a hopeful note, suggesting that if all else fails, one job remains that AI can’t do: creating the data it needs to learn. This humorous yet poignant reminder emphasizes that for all its power, AI remains a tool that requires human input and guidance.

Want to know what else was discussed at Infobip Shift at Zadar in 2025? Find out here!

The post Will AI (Finally) Replace Developers? It’s Complicated. appeared first on ShiftMag.