If you’re ready for a break from artificial intelligence, Google I/O won’t be your safe haven. The annual developer conference — which starts next week in Mountain View, Calif. — and also offers a large virtual option, is expected to focus heavily on Google’s latest developments in AI, especially its Gemini family of products.

Google held The Android Show: I/O Edition last week where it unveiled Android 16’s new Material 3 Expressive design language and Gemini AI integration for Android Auto and Wear OS. Expect further Android news during I/O. This could include more details on Android 16’s features, potentially including new privacy enhancements, scam-detection features, and updates to the Find Hub.

But there’s no doubt Gemini will be the star of the show. Following Google’s recent developer preview of Gemini 2.5 Pro, the company is likely to demonstrate significant performance gains, new applications, and expanded availability of its flagship AI.

Look for updates on how Gemini is enhancing Google Search, Google Workspace applications, and possibly new AI agent capabilities. Another topic to watch is Project Astra, Google’s vision for a universal AI assistant that can understand the real world through video and audio.

Follow this page for the latest on Google I/O 2025.

Google I/O news and analysis

Android’s in for a reinvention — and it has nothing to do with AI

May 14, 2025: Android’s most shape-shifting future features are right in front of us, but they aren’t what you might expect. You may learn more next week at Google I/O.

Google to unveil AI agent for developers at I/O, expand Gemini integration

May 13, 2025: Google is expected to unveil a new AI agent aimed at helping software developers manage tasks across the coding lifecycle, including task execution and documentation.

Google updates Gemini 2.5 Pro model for coders

May 6, 2025: Google has updated its Gemini 2.5 Pro AI model with stronger coding capabilities, hoping developers would begin building with the model before the Google I/O developer conference next week. Released May 6, Gemini 2.5 Pro Preview (I/O edition) is accessible in Google AI Studio tool and in Vertex AI.

Microsoft has announced the general release of Visual Studio 2022 version 17.14, an update of the company’s flagship integrated development environment (IDE) that adds support for agent mode and other AI-assisted development features from GitHub Copilot.

Released May 13, Visual Studio 2022 version 17.14 can be downloaded from visualstudio.microsoft.com. The 17.14 release previews GitHub Copilot agent mode to “supercharge” the AI-assisted development experience, Microsoft said. With agent mode, developers chat with Visual Studio using natural language to instruct it to complete multi-step, complex coding tasks autonomously. The agent understands the code base and can fix errors, suggest and execute terminal commands, and analyze runtime errors until a task is complete, Microsoft said. Agent mode is available in public preview for all users of Visual Studio 17.14.

Visual Studio 17.14 also adds Next Edit Suggestions (NES), whereby GitHub Copilot predicts the next edit in the current file based on previous edits, and AI-powered doc comment generation for C++ and C# functions. The release also adds support for Model Context Protocol (MCP), also preview. An open-source protocol created by Anthropic, MCP provides the GitHub Copilot agent with structured access to data, tools, and resources.

Visual Studio 17.14 brings numerous other new features. Debugging and diagnostics have been enhanced with a Live Preview at design time, allowing users to see changes in an app in real time. Developers also can use Hot Reload and other live UI tools in this manner. A Mono debug engine for .NET MAUI (Multi-platform App UI) has been integrated into the Visual Studio Core debugger. A preview of C++ dynamic debugging offers full debuggability for optimized C++ code with no compromise on performance, according to Microsoft. C++ 23 improvements include support for new lambda attributes, if consteval, and static operators, enhancing both code efficiency and safety. And productivity for C++ development has been improved with features like automatic template argument population and improved IntelliSense for CMake modules, Microsoft said.

Git tools in Visual Studio 17.14 have been enhanced with a new setting to keep a repository open between starts. A default branch setting for Git, meanwhile, lets users customize the initial default branch when a new repository is created. The Git Repository window now provides a filter to show only outgoing and incoming commits.

 Other improvements in Visual Studio 2022 version 17.14 include the following:

• The NuGet authentication process has been improved. If any potential authentication issues are detected, developers now see a new authentication dialog that provides context about the feed and the specific account needs.
• The installer now supports Extension Packs. These are bundles of multiple extensions referenced from a single extension.
• The WinForms out-of-process Designer for .NET Framework projects now automatically discovers and displays controls present in standalone assembly references. This feature is known as Explicit Assembly References.

Informatica is partnering with Microsoft, Oracle, and Salesforce to extend support of its Master Data Management (MDM) service and extensions and help enterprises build applications for agentic and other generative use cases based on more accurate data.

Analysts see Informatica’s efforts to extend MDM to cloud service providers as a boon for enterprises because hyperscalers have not been focusing on building or improving MDM as a capability despite building data intelligence and integration capabilities.

“MDM is a critical element in supporting agentic AI. It promotes creation of a trusted dataset or single source of truth for the people, places, and things that enterprises care about, which will be critical in providing the right data in the right context to autonomous agents,” said Stewart Bond, research vice president at IDC.

Informatica’s partnership with Oracle will allow enterprises to use Informatica’s MDM service and other components of its Intelligent Data Management Cloud (IDMC) natively within OCI, the enterprise data management software provider said.

The native usage of MDM in OCI could provide benefits such as the ability to adopt a multi-domain MDM approach to manage critical data entities across multiple domains, resulting in improvement of data consistency and governance, both necessary for agentic and generative AI use cases, Informatica said.

Bond said that Oracle’s partnership with Informatica for MDM will give enterprises more options to consider for conducting MDM-related processes, as Oracle has its own MDM, data intelligence, and data integration capabilities.

The partnership with Oracle will also see Informatica providing connectors for streamlined use of IDMC with Oracle Autonomous Database, Oracle Object Storage, making data from these Oracle sources available to be accessed.

MDM via Informatica’s IDMC for OCI will become available to enterprise customers in the month of October this year, Informatica said.

MDM extensions for consolidating data in Microsoft Fabric

As part of its strategy to extend MDM support across major data analytics and database providers, Informatica has now added support for MDM extensions in Microsoft Fabric to help enterprises consolidate data.

These extensions, often termed as MDM360 extensions, according to Informatica, are preconfigured assets that are expected to streamline implementations. Currently, the company offers two types of extensions — integration and industry-focused.

The integration-focused extensions help enterprises set up MDM for common data sources, such as SAP and Salesforce.

The support for MDM in Microsoft Fabric is a combination of these integration-focused extensions, which will allow enterprises to consolidate data from multiple sources in Fabric before setting out to build AI-based applications.

“Users can now leverage pre-built integration assets to expedite data onboarding and effortlessly replicate comprehensive master data models, including customer, product, supplier, location, and more, into Microsoft Fabric,” the company said, adding that MDM extensions support for Microsoft Fabric has been made generally available.

IDC’s Bond sees Informatica’s integration with Fabric as the former’s strategy to incorporate its MDM services more natively across all major cloud service providers, such as Google Cloud, AWS, and Microsoft.

“IDMC is available on all of the public clouds, and so theoretically, Informatica MDM is available to be used on all public clouds, but as a separate application and domain — not integrated with the data intelligence and integration offerings available on the same clouds,” Bond said, adding that these integrations will help deliver more value for enterprises.

In addition, Informatica said that it was introducing a data quality native application in Fabric in public preview to help enterprises clean data from inside the Fabric environment.

More partnerships for expanding MDM integrations

Informatica has similar MDM integrations with enterprise software vendors, such as Salesforce and ServiceNow, and is now executing its strategy to expand them.

“The first cloud-resident MDM offering from Informatica was a partnership with Salesforce, but that was with a previous generation of product,” Bond said.

As part of its expanded partnership with Salesforce, the company is integrating its IDMC platform in Agentforce in order to enhance agents built on the CRM platform with real-time data.

This planned integration with Agentforce, according to Bond, reinforces the need for master data in agentic architectures. While Salesforce uses its Data Cloud as the primary customer data platform in order to collect manage sales and marketing data along with external signals to help understand customer experience and sentiment, Informatica’s MDM integration will provide Agentforce users with mastered customer data from enterprise systems — account data, order data, returns data, interaction data and so on, Bond explained.

Python’s popularity continues to outpace all competition. That’s why projects to make it faster are crucial, difficult as that may be. Plus, Python’s new, standardized dependency lockfile format is here. And if you’re a fan of Zig for speed and Python for convenience, we show how to make both languages live in harmony.

Top picks for Python readers on InfoWorld

Python’s popularity at its highest ever
No programming language has been this popular since Java in 2001. And Python’s lead over rival programming languages is growing.

Making Python faster won’t be easy, but it’ll be worth it
It will be a struggle to make Python faster, no thanks to its dynamism and legacy support needs. But it’s happening, and the effort is already paying dividends to the language’s massive user base.

Understand Python’s new lock file format
Lock files for tracking Python dependencies used to come only from third-party tools. Now Python has its own native lock file format. See how it shapes up against the existing ad hoc standards

How to boost Python program performance with Zig
Zig is being touted as the next big thing for C-style programming. Because Zig exposes a C-like interface, you can wrap Zig in Python and get speed and convenience together.

More good reads and Python updates elsewhere

Say goodbye to the standalone PyCharm Community
JetBrains is combining PyCharm Community and PyCharm Professional into a single, unified PyCharm download. The familiar, free-to-use community features are still free, and the source for PyCharm Community remains available, too.

A very early first peek at Astral’s Rust-powered Python type checker
Word leaked out a little before ty was ready for prime time, but you can now try out this lightning-fast type checking tool for Python (from the makers of uv). Warning: it’s still alpha!

Meta unveils its own Rust-powered Python type checker, Pyrefly
Not to be outdone, Meta has unveiled its own tool in this space. Like ty, Pyrefly is in its alpha stages, so use with caution.

Slightly off-topic: Plain vanilla web dev
How to get back to no-frameworks, no-frills, web building basics with bog-standard HTML, CSS, and core JavaScript.

The influence of geopolitics on IT infrastructure is undeniable. Enterprises today operate across borders. They leverage cloud services from providers headquartered in countries thousands of miles away, host data in various regions, and deliver value globally. However, as geopolitical tensions escalate, this once seamless global business flow is under threat.

Risks extend far beyond trade tariffs or sudden price spikes from inflation. Enterprises must now consider the possibility of government intervention in the form of sanctions, data seizures, or politically motivated disruptions. For instance, a cloud provider based in one region might find itself involved in disputes that hinder its ability to deliver uninterrupted service elsewhere. Moreover, stricter data privacy and cloud sovereignty regulations, particularly in regions such as the European Union, are expanding.

This isn’t just a theoretical problem. Many CIOs and business leaders have watched their most secure supply chains collapse overnight because risks were overlooked until it was too late. The same lessons must now be applied to IT ecosystems. To protect business continuity and compliance, these new realities demand a more nuanced approach to cloud adoption.

From simplicity to heterogeneity

One of the most profound changes we’re seeing today is the move away from simplicity in favor of heterogeneity. No longer is the IT architecture merely a question of choosing between on-premises systems and a single, dominant cloud partner. Enterprises are now building hybrid, multicloud, and even distributed solutions that mix hyperscalers, sovereign clouds, and local partners. With this approach comes greater levels of complexity but also newfound resilience.

Many on-premises systems today rely partly on cloud-tethered capabilities, whether it’s threat intelligence for security, Internet of Things devices managed via the cloud, or essential software updates linked to a vendor’s cloud infrastructure. Going “all-in” on a single hyperscaler or geographic location now creates single points of failure that most enterprises cannot afford.

Furthermore, the rise of sovereign clouds—regional or national cloud services designed to meet strict data sovereignty requirements—is increasingly becoming a viable alternative for businesses operating in sensitive markets. The concept of “geo-patriation” is also gaining traction, which involves migrating workloads and applications from multinational service providers to local ones. Although these solutions may not match the scale of hyperscalers, they satisfy all the criteria for compliance, security, and sovereignty for certain workloads.

Complexity: a necessary trade-off

Adapting to this new reality presents its own challenges that extend beyond just technical questions. Enterprises now face higher costs, longer implementation timelines, and increased dependence on in-house expertise to manage bespoke architectures. Switching cloud providers or transitioning to new ecosystems is rarely a straightforward task, yet it is necessary.

This isn’t merely a technical evolution—it’s a strategic shift requiring buy-in from stakeholders. Business decision-makers must align with IT teams, risk analysts, and legal experts to determine acceptable trade-offs. What sacrifices are worth making in exchange for resilience? What costs can the business absorb?

Crucially, enterprises must address these questions not as reactionary measures but as elements of long-term planning. Gartner predicts that most organizations take at least two years to switch cloud providers under normal conditions, meaning a crisis is not the time to begin planning. Enterprises must actively explore hypothetical scenarios, mapping out the specific geopolitical risks for each key vendor, workload, and region. Proactive planning will distinguish those who survive from those who will be caught unprepared by the next global disruption.

Mix-and-match infrastructure

Enterprises must prioritize resilience by adopting a more strategic and diversified approach to managing cloud dependencies. Begin by mapping out not only direct cloud dependencies but also hidden reliance on cloud-based capabilities within on-premises systems, IoT devices, and software licensing. Assess the geopolitical exposure of each vendor, including where they are headquartered, operate, and store data, to identify vulnerabilities.

Next, plan for greater heterogeneity in IT architectures. This includes embracing hybrid, multicloud, and regional or specialized cloud providers to reduce reliance on single hyperscalers such as AWS, Microsoft, or Google. This shift may increase complexity and costs and require upskilling in-house teams, but the payoff is stronger business continuity during disruptions.

Scenario-based planning is crucial. Anticipate potential risks such as price spikes, trade disputes, or access restrictions, and develop contingency strategies tailored to these disruptions.

Finally, involve cross-departmental decision-makers. Cloud strategy is now a critical business concern, not merely an IT issue. Aligning technology, legal, and financial perspectives ensures that trade-offs won’t catch you by surprise. By embracing diversification, planning ahead, and reducing exposure to geopolitical risks, enterprises can build the resilient IT strategies necessary for today’s volatile world.

The days of one-size-fits-all cloud strategies are over. IT ecosystems are now characterized by flexibility, agility, and resistance to over-centralization. Although hyperscalers will continue to play a critical role in global IT environments, their dominance is no longer guaranteed.

The new normal is a world where technological strategies are deeply entwined with political realities, and partnerships must be crafted with an eye toward compliance, sovereignty, and geopolitical exposure. For enterprises, the message is clear: Embrace heterogeneity, invest in long-term planning, and recognize that diversity in your IT strategy is more than a hedge against risk—it’s a strategic advantage.

Uno Platform 6.0, a major update to the open source tool kit for building cross-platform .NET applications from a single code base, introduces a new, unified rendering engine, called Skia, that gives developers a low-footprint, high-performance, hardware-accelerated option for running apps on iOS, Android, Web/WebAssembly, Mac, Linux, and Windows.

Described by the Uno Platform Team as the biggest release ever, Uno Platform 6.0 was announced in a blog post on May 7.

While Uno Platform also supports native UI rendering for these platforms, the Skia rendering engine brings “massive” performance advantages, the company said. These include up to 75% smaller footprint, 60% faster startup, 30% less memory, and 45 times faster to run, according to the Uno Platform Team.

Uno Platform 6.0 also introduces two new UI components. The Media Player Element from Windows UI now is available for all targets supported by Uno Platform, including the Skia-based targets. Also now available is the WebView2 control, which enables users to navigate to external content and display custom HTML content. WebView2 also facilitates communication between C# and JavaScript, the company said, supporting embedding scenarios such as interacting with JavaScript charting or data grid components.

Instructions on migrating to Uno Platform 6.0 can be found at platform.uno. Also announced was general availability of Uno Platform Studio, which features a suite of tools for building cross-platform apps. In coming months, the Hot Design visual designer that is part of the Uno Platform Studio will be fitted with more AI functionality along with richer editors and advanced item and page templates, the Uno Platform Team said.

The growing number of large language models (LLMs) from various providers—Anthropic, Google, Meta, Microsoft, Nvidia, OpenAI, and many others—has given developers a rich set of choices but also has introduced complexity. Each provider has its own API nuances and response formats, making it a challenge to switch models or support multiple back fends in one application. LiteLLM is an open-source project that tackles this fragmentation head-on by providing a unified interface (and gateway) to call more than 100 LLM APIs using a single, consistent format.

In essence, LiteLLM acts as a “universal remote” for LLMs, allowing developers to integrate a diverse set of models as if they were calling OpenAI’s API, regardless of the underlying model provider.

Since its launch, LiteLLM has quickly gained traction in the AI developer community. The project’s GitHub repository (maintained by BerriAI, a team backed by Y Combinator) has garnered over 20,000 stars and 2,600 forks, reflecting widespread interest. Part of this popularity stems from the real-world needs it addresses. Organizations including Netflix, Lemonade, and Rocket Money have adopted LiteLLM to provide day-zero access to new models with minimal overhead. By standardizing how developers interface with LLM providers, LiteLLM promises faster integration of the latest models and smoother operations across an ever-evolving LLM ecosystem.

In this article, we’ll discuss LiteLLM’s origins and goals, dive into its core functionality and key features, and examine how it simplifies LLM usage through practical examples. We’ll also discuss the enterprise edition of LiteLLM for commercial use and compare it to a few alternative solutions.

Project overview – LiteLLM

LiteLLM is designed as a universal adapter for LLM APIs, allowing developers to interact with various providers through a standardized interface. The project supports leading LLM providers including Anthropic, AWS Bedrock, AWS SageMaker, Azure OpenAI, DeepSeek, Google Vertex AI, OpenAI, and Ollama.

The project is built around two core components: the Python SDK and the Proxy Server. The Python SDK provides developers with an easy-to-use library for integrating multiple LLMs into their applications. Meanwhile, the Proxy Server acts as a production-grade gateway for managing LLM usage at scale. It offers centralized cost tracking, access control, and real-time monitoring of API calls.

The motivation behind LiteLLM is to simplify the development of multi-LLM applications and reduce the friction for platform teams in managing multiple model providers. According to the maintainers, LiteLLM simplifies model access, spend tracking, and fallbacks across more than 100 large language models.

In practical terms, LiteLLM aims to save time and effort for development teams. Instead of writing custom integration code for each new model API or waiting for vendor-specific SDKs, developers can use LiteLLM’s unified SDK and Proxy Server to gain immediate compatibility.

What problem does LiteLLM solve?

Developers often face significant challenges when integrating multiple LLMs into their applications. One of the primary issues is API heterogeneity, as different providers have different input/output formats and authentication mechanisms, which can complicate development. Additionally, managing fallbacks to respond to provider outages or rate limits requires custom code that can be error-prone and time-consuming to implement.

Another common pain point is cost opacity. It becomes difficult to track spending accurately when using multiple LLMs across different projects or teams. Organizations risk exceeding budgets or failing to optimize costs effectively without proper tools.

LiteLLM addresses these challenges by providing a unified API that standardizes interactions across all supported providers. It also includes built-in features like automatic retries for failed requests and real-time cost analytics, making it easier for developers to focus on building applications rather than managing infrastructure.

A closer look at LiteLLM

LiteLLM is designed to be both flexible and powerful. At its core is the ability to translate all API calls into OpenAI’s familiar completion() syntax, regardless of the underlying provider. This means developers can switch between models without significantly changing their code base.

For example, if a developer wants to use Anthropic’s Claude 3 instead of OpenAI’s GPT-4 for a particular task, they need only to specify the model name in their request. LiteLLM handles the rest, including authentication and formatting.

In addition to the unified API, LiteLLM includes advanced features like dynamic fallbacks and structured outputs. Dynamic fallbacks allow requests to be routed to a backup model automatically if the primary model fails or becomes unavailable. Fallbacks ensure high availability even during provider outages. Structured outputs allow developers to validate responses using Pydantic schemas, reducing errors in downstream processing.

Here’s how you can use LiteLLM to call Anthropic’s Claude 3 using OpenAI’s format:

from litellm import completion

response = completion(
    model="anthropic/claude-3",
    messages=[{"role": "user", "content": "Explain quantum computing"}]
)
print(response.choices[0].message.content)  # Outputs Claude's response

For production environments, the LiteLLM Proxy Server can be deployed as a centralized gateway. This allows multiple teams or applications to share access to LLMs while maintaining control over costs and usage limits:

litellm --model openai/gpt-4 --api_key sk-xyz

Then clients can interact with the Proxy Server using standard OpenAI libraries:

import openai
client = openai.OpenAI(base_url="http://localhost:8000")
client.chat.completions.create(model="gpt-4", messages=[...])

Key use cases for LiteLLM

LiteLLM offers several commercial-grade features that make it suitable for enterprise use cases. One of its most popular applications is multi-cloud LLM orchestration. Enterprises often use multiple providers to ensure redundancy or to optimize costs based on specific tasks. With LiteLLM, developers can distribute requests across different providers seamlessly:

response = completion(
    model=["azure/gpt-4", "aws-bedrock/claude-3"],
    messages=[{"role": "user", "content": "What are black holes?"}]
)

Another key feature for enterprises is cost governance. LiteLLM provides real-time cost analytics through the Proxy Server dashboard. Organizations can set monthly budgets for different teams or projects and monitor spending across all supported models. This level of transparency helps prevent budget overruns and ensures efficient resource allocation.

Audit compliance is another area where LiteLLM excels. The Proxy Server logs all input/output metadata securely, making it easier for organizations to meet regulatory requirements or conduct internal reviews.

Bottom line – LiteLLM

LiteLLM is more than just an open-source project—it’s a comprehensive solution for managing multi-provider LLM deployments at scale. LiteLLM empowers developers to build robust generative AI applications without worrying about infrastructure complexities by simplifying API interactions and adding powerful features like dynamic fallbacks and cost analytics.

LiteLLM’s combination of Python SDK and Proxy Server makes it suitable for both small teams experimenting with AI and large enterprises running mission-critical workloads. With active community support and continuous updates from BerriAI, LiteLLM is well-positioned to become the go-to choice for unified LLM access in the years ahead.

In the past decade or so, there’s been a push to put everything online. From customer service to interactions with local and national governments, we’ve moved away from the call center to the web and self-service. That push has streamlined interactions and simplified complex relationships, but it has also shown us a significant weak spot: how poorly the web serves people who use assistive technologies.

Design for accessibility is key to any web application. We need the biggest possible reach for our code, and that means providing the necessary hooks for assistive technologies. The more provisions our code has, the better things can be for the widest number of users. Accessibility is a key foundation of modern UI development, as it helps support everyone, not only people with disabilities, but those using text-to-speech in a car, a mother holding a baby, or someone with a broken arm who has to type with one hand for a few weeks. As accessibility advocates regularly note, we are all likely to need help at some point in our lives.

Microsoft has supported accessibility features across its development tools for a long time, building them into its display platforms, including Edge, its Chromium-based browser, and the WebView2 HTML canvas control.

Using ARIA to support assistive technology

A key accessibility technology is ARIA (accessible rich internet applications). A W3C standard, it defines how pages describe themselves to external assistive technologies. In Edge, both HTML and ARIA content is parsed and used to build a separate, accessible view of your site content. Screen readers and similar tools use Edge’s automation APIs to access that view, providing ways to interact with content, such as voice navigation or speech recognition in forms.

ARIA builds a semantic description of web content for use by screen readers and other tools. It mixes computed elements based on the HTML structure of a page and its own attributes. Microsoft has worked with the HTML 5 Accessibility project to show what features are available in Edge, helping on a site redesign that shows sample code for tests and provides a useful guide for how to build ARIA and other accessibility features into your code.

Using Edge Dev Tools to test accessibility

Once you’ve started to build accessibility into your sites, you can use the Edge F12 developer tools to check site code for ARIA support. Right-click on a page and choose Inspect to launch the developer tools. In the top right of the DOM view, you’ll see an icon of a human figure. Click this to open the accessibility tree for the page.

In the lower pane of the developer tools, choose Accessibility to open an inspector, and then scroll through the tree to see ARIA attributes associated with page elements. For example, it can show you the additional markup for a table of contents as a tree with items that can be selected via assistive tools.  This is a quick way to find out if your accessibility features are parsed by Edge and that you’re using the right descriptions.

One criticism of this tool: It’s not as easy to find as it should be. The Accessibility tab wasn’t visible by default. Making it a sub-feature of the Elements tool shows that it’s not a priority. Microsoft’s Edge developer tools team should make it a high-level tool in its own right to show how important accessibility is to the modern web.

Introducing ARIA Notify

ARIA is evolving, with a new set of APIs currently being tested in new builds of Edge. ARIA Notify is designed to work with modern page design techniques where the visual state of a page isn’t necessarily tied to a change in the DOM. If you’re using ARIA, these changes won’t be detected, and although there are workarounds, they aren’t perfect and they won’t work in a number of scenarios, such as in a text editor where you’re making a formatting change, or where a UI element is linked to an asynchronous event and where notifications can happen when a user is interacting with another part of a view.

The new ARIA Notify API avoids many of these issues by offering a basic messaging API that provides any assistive technology (like a screen reader) with the details associated with an action. Say you’re selecting some text in an editor and making it italic. Calling ARIA Notify with the selected text and the action name will deliver the required message to the user.

It’s available as a method attached to the JavaScript document object and any of its nodes, so it’s relatively simple to add ARIA Notify support to most actions. However, that raises another set of issues with overlapping messages and differing levels of importance. You don’t want to lose an important notification in a crowd of messages as a user navigates a menu.

Prioritizing ARIA notifications

ARIA Notify is intended to deliver information about in-browser UI events, so it needs some form of prioritization to handle this type of occurrence. Assistive technologies will need to implement some kind of message queue to categorize messages as either high priority or normal priority. High-priority messages are assumed to have their own queue that overrides normal-priority messages. If a high-priority flag arrives, the current normal-priority message continues to be processed, and the high-priority message then takes first position in the queue.

Microsoft provides two ways to use this new API, as it’s still very much in development. You can use a command line flag to enable it in Edge Canary for your own tests, or if you prefer, you can register your site as part of an Edge Origin Trial to test with external users (in this case, with assistive technology vendors or specific users).

Using Edge Origin Trials

Edge Origin Trials are an interesting tool. Microsoft provides a list of the current trials, which are time-limited, and you can register a site for any of them. If you’re signed in via GitHub, you can register a domain for the trial. You are then issued a token that can be included as a meta element in a page head tag or as a specific HTTP server response. Tokens don’t have to be a fully qualified domain; you can use subdomains for more targeted tests. You can’t use a specific path, as Edge Origin Trials can be enabled only at a domain level.

From a user’s point of view, they don’t need to do anything to test the new feature. As long as their browser supports the feature being tested, the existence of the trial token is enough to enable it. There’s no need to set browser feature flags or use a command line to launch their browser. Tokens last as long as the planned trial; if the trial is extended, they will need to be renewed.

Microsoft’s Edge browser is continuing to evolve to support all users, and the combination of ARIA and ARIA Notify will go a long way to taking existing web applications and supporting a new generation of assistive technologies. Using ARIA Notify, we should be able to support common design elements such as carousels, where not all the content is visible and a user needs to navigate through a dynamically loaded set of content.

Supporting standards like these is vitally important, as the more services (both government and commercial) we put online, the more we risk disenfranchising users who need accessibility support. Adding a little more markup to a page or a new method to a JavaScript operation seems a tiny price to pay for ensuring as many people as possible can use our code.

Agentic AI requires a whole new type of architecture; traditional workflows create serious gridlock, dragging down speed and performance.

Databricks is signaling its intent to get ahead in this next generation of app building, announcing it will purchase open-source serverless Postgres company Neon. The startup’s platform can spin up new database instances in less than a second, making it purpose-built to support agentic workflows.

This move “allows Databricks to strengthen its AI infrastructure capabilities, specifically in areas like AI-driven database provisioning and the development of AI agents, a notable gap they are seeking to fill as their competitor Snowflake currently lacks these features,” said Scott Bickley, advisory fellow at Info-Tech Research Group.

AI building AI

After the $1 billion acquisition, Neon’s serverless Postgres architecture will be integrated with the Databricks Data Intelligence Platform, allowing developers to quickly build and deploy AI agents without having to concurrently scale compute and storage. This approach can prevent performance bottlenecks while simplifying infrastructure and reducing cost, Databricks says.

Many of the tasks AI agents perform require launching a database for information retrieval, but that can take several minutes, slowing responses, the company noted. Neon’s ability to create near-instant database instances allows AI agents to react quickly. Additionally, databases can be flooded with requests from multiple agents, also hampering speed; Neon can create separate copies of database content for each individual agent.

According to recent internal telemetry, 80% of databases on the Neon platform are created automatically by AI agents rather than humans. Neon says it can spin up a fully-isolated Postgres instance in 500 milliseconds or less, and supports instant branching and forking of database schemas as well as data, so production isn’t halted.

“Traditional database systems can’t keep up with the scale and variability of agent-driven architectures, where thousands of temporary databases are spun up and shut down rapidly,” explained Robert Kramer, VP and principal analyst at Moor Insights and Strategy.

Neon’s serverless Postgres model, when integrated with the Databricks platform, will provide instant provisioning, separation of compute and storage, and API-first management, he noted. “Organizations can reduce infrastructure costs, speed up deployment cycles, and improve experimentation without disrupting production.”

According to Databricks, Neon’s platform is 100% Postgres-compatible and works out of the box with several popular extensions It also provides a cost structure that scales with usage.

“We’re giving developers a serverless Postgres that can keep up with agentic speed, pay-as-you-go economics, and the openness of the Postgres community,” Ali Ghodsi, co-founder and CEO at Databricks, said in a statement.

Setting out to disrupt the database industry

Neon’s clients include Replit, Retool, Boston Consulting Group, Vercel, Cloudera, and Cloudflare, according to its website.

In an announcement, its founding team said they set out to “disrupt the database industry” and create a new architecture that separates storage and compute and introduces a “branchable, versioned storage system.” The idea wasn’t to build a wrapper around Postgres or offer managed hosting, “it was a fundamental rethink of how Postgres should work in the modern era,” they said.

Neon was launched publicly in 2022, and soon became one of the fastest-growing developer databases on the market. Once the transaction closes, many of its team members are expected to join Databricks.

The latest in a string of strategic moves

Databricks has been making strategic purchases to position itself as a top platform for building, testing, and deploying AI. In 2023, it purchased open source large language model (LLM) training platform MosaicML for $1.3 billion, and last year it scooped up data storage company Tabular for more than $1 billion.

“Databricks has been aggressive in its acquisition of companies that have accelerated their core technology platform,” said Bickley.

He added that linking generative AI model-building capabilities from Mosaic with Apache Iceberg and Delta Lake formats has been a “powerful enhancement,” and lent itself to the recently-announced SAP-Databricks partnership, which will merge contextual ERP data with external data sources.

What IT buyers should keep in mind

Integrating Neon’s model into legacy systems and rethinking database governance for agent-driven architectures will take time and careful planning, Kramer emphasized. He noted that the AI data infrastructure market is crowded, so Databricks may face a challenge in differentiating itself.

“They must ensure that Neon scales reliably, integrates with enterprise environments, and has the proven track record of success,” he said. He added that the true test will be whether customers can effectively utilize these new capabilities at a large scale without introducing additional complexity.

Bickley also urged IT buyers to be cautious, particularly when it comes to pricing. While a consumption-based subscription model can offer cost efficiency, if not properly governed or contractually structured it can “bleed enterprise budgets with runaway, unmanaged costs,” he noted.

“In its current form, Neon offers robust capabilities to control costs via its scale-to-zero feature,” he said.

Adopters should also focus on product absorption timelines, as well as preservation of Neon’s open source culture and community and Apache 2.0 licensing. It’s reasonable to expect some proprietary, fee-based products (such as managed Neon instances), he noted, and Databricks will likely integrate features with those from Mosaic and Tabular.

“All things considered, this acquisition enhances Databrick’s comprehensive capabilities as it builds a leading data management suite, providing buyers with the option to rationalize vendors in the data management space,” said Bickley. “Bringing best-in-class serverless database capabilities into the fold and extending their use via AI agents sets Databricks apart for now.”

More on Databricks:

• Databricks acquires BladeBridge to aid data warehouse migrations
• Databricks’ TAO method to allow LLM training with unlabeled data
• Databricks’ new updates aim to ease gen AI app and agent development
• Databricks to infuse $250M to double its R&D staff in India this year

With the fourth preview of the planned .NET 10 software development platform, Microsoft has delivered a variety of enhancements to the platform’s libraries, runtime, and frameworks, including faster processing of GZip data streams and escape analysis for local struct fields in the JIT compiler.

.NET 10 Preview 4, announced May 13, is downloadable from dotnet.microsoft.com.

Among the library improvements, .NET 10 Preview 4 boosts performance and memory usage of GZipStream when processing concatenated GZip data streams. Prior to this, each new stream segment would dispose and reallocate the internal ZLibStreamHandle; this resulted in additional memory allocations and initialization overhead. With this change, the handle now is reset and reused using inflateReset2, reducing both managed and unmanaged memory allocations and improving execution time. Preview 4 also introduces asynchronous APIs for working with Zip archives, making it easier to perform non-blocking operations when reading from or writing to Zip files.

For the .NET runtime, .NET 10 Preview 4 expands the JIT compiler’s escape analysis abilities to model references to objects from struct fields. The JIT performs escape analysis to determine if an object can outlive its parent method; if not, the JIT can allocate the object on the stack, removing the overhead of placing and tracking an object on the heap. Preview 4 also lets developers can collect runtime diagnostic information from Blazor WebAssembly apps, including performance profiles, memory dumps, and runtime metrics.

Also in .NET 10 Preview 4, the Blazor WebAssembly Standalone app template has been updated to enable preloading of state framework assets, include a generated JavaScript import map. And developers can use the new InvokeNewAsync and GetValueAsync/SetValueAsync methods to call JavaScript constructors and properties from .NET.

.NET 10 Preview 4 follows Preview 3 from April 10, Preview 2 from March 18, and Preview 1 from February 25. The general production release of .NET 10 is expected in November. Other new features and improvements in .NET 10 Preview 4 include:

• For the .NET Activity class, Preview 4 supports serializing tracing data out-of-process using the Microsoft-Diagnostics-DiagnosticSource event source provider. It also adds support for serializing ActivityLink and ActivityEvent metadata.
• Also for the .NET Activity class, a new sampling option called Rate Limiting Sampling restricts the number of root activities serialized per second, providing more precise control over data volume.
• For the F# language, handling of generic unmanaged structs has been improved.
• For .NET for Android, the Android workload previously installed a copy of Mono.Android.dll per architecture, even though the contents of each of these files were identical. This duplication has been removed.
• For Windows Presentation Foundation, performance has been optimized across font rendering, dynamic resources, input composition, trace logging, regex usage, and XAML parsing. Further, redundant allocations have been removed and core internals streamlined for improved efficiency.

AI-driven automation platform vendor Boomi has unveiled products and partnerships to advance its enterprise automation AI strategy.

The announcements at the Boomi World conference reflect a “commitment to business transformation through a unified, open, and AI-native platform,” the company said on Wednesday.

On the product front, Boomi announced the general availability of Boomi Agentstudio, formerly known as Boomi AI Studio, a no-code environment that lets organizations design, govern, and orchestrate AI agents at scale.

In conjunction with this release, the company announced that it has expanded its integration capabilities to include Amazon Q Business. Boomi is now an approved Data Processor for all Amazon Web Services (AWS) customers. Agentstudio’s governance now supports centralized agent registration for Amazon Bedrock, and a new Agent Step capability lets enterprise developers embed agents into the Process Canvas.

Four new AI agents have been added to Boomi Enterprise Platform, available to customers at no additional charge.

Integration Advisor Agent autonomously reviews integration processes, providing actionable feedback to improve integration efficiency and maintainability

API Design Agent lets customers rapidly design and edit application programming interfaces (APIs) by autonomously generating OpenAPI specifications that, Boomi said, “leverage best practices for compliant and comprehensive API definitions.”

API Documentation Agent handles the bugbear of all developers, documentation, by autonomously generating business and technical docs from API definitions.

Data Connector Agent lets users design and create data integration connectors for any REST-based data source.

“These intelligent agents operate alongside developers, handling complex tasks, simplifying workflows, and speeding up the integration of applications, data, and APIs,” Boomi Chief Product and Technology Officer Ed Macosky said in an email. “The result: faster time-to-value and improved operational performance.”

Boomi Data Integration, formerly Rivery (which Boomi acquired in December 2024), is now part of the Boomi Enterprise Platform. It offers automated end-to-end data pipelines with managed data connectors, log-based change data capture, and enhanced observability that will allow users to ingest, transform, and activate data from any source.

It is unclear whether this feature will be free, however. “We’re still finalizing the scope and rollout details for those capabilities, so we’re not sharing specifics just yet” Macosky said. “What we can say is that our goal remains consistent: to deliver as much value as possible through the platform in a way that aligns with customer needs.”

Although it’s not there yet, Boomi also announced that it will build support for Model Context Protocol (MCP), a new open standard that allows AI agents to connect to data sources, into the Boomi Enterprise Platform.

“Support for MCP is on the roadmap and actively in development,” said Macosky. “While we’re not sharing exact release dates yet, it’s a top priority and will be introduced in phases over the coming months as part of our continued platform innovation.”

Jason Andersen, VP and principal analyst at Moor Insights & Strategy, is impressed. “Boomi’s new capabilities underscore two often underrepresented aspects of agents and agentic workflows: tool integration and governance,” he said. “For agents to be meaningful within an enterprise context, secure and reliable access to APIs, applications, and data sources is critical. Capabilities like the ones Boomi is offering will accelerate the delivery of high value and high scale agents.” 

“By positioning itself as the central management plane for agent deployments, Boomi’s platform is positioning itself as the enterprise nerve center to build and manage enterprise agentic workflows,” added Andrew Sharp, research director, Info-Tech Research Group. “These new capabilities help enterprises solve persistent challenges around data silos, disjointed processes, and shadow IT. A unified integration platform with embedded, cutting-edge AI management and governance capabilities will enable organizations to embrace AI strategies at scale.”

Strategic collaboration with AWS

In addition to the product announcements, Boomi announced a strategic collaboration with AWS which includes the integration of Amazon Bedrock with Boomi Control Tower, the company’s centralized management tool for deploying, monitoring, and governing AI agents across hybrid and multi-cloud environments. Control Tower is part of Agentstudio, and, Boomi said, gives customers visibility, monitoring, and control of both Boomi-authored and third-party AI agents.

In addition, Enhanced Agent Designer integrates Boomi’s low-code agent designer with Amazon Q index to allow users to build, train, and deploy intelligent agents leveraging Amazon Q index.

The company also announced a set of native data connectors for AWS Lambda, Amazon Bedrock, Amazon DynamoDB, and the Amazon Selling Partner Appstore.

Finally, Boomi for SAP provides SAP-certified integration to provide connectivity between SAP and non-SAP systems. It supports cloud migration, including ELT capabilities powered by the Rivery acquisition, allowing customers to move SAP data into any AWS-powered data warehouse or data lake.

“Boomi’s new partnership with AWS is a powerful combo, since AWS Bedrock is an emerging leader in agentic development and Boomi brings a level of integration and governance to enterprise agents,” Andersen said. “This should enable enterprises to build richer and more contextual agents.”

This story has been updated with comments from Info-Tech Research Group.

Informatica (Nasdaq:INFA) is preparing ready-built AI agents and agent-building tools to help enterprises automate their use of its Intelligent Data Management Cloud (IDMC).

Claire Agents will help enterprises use natural language to automate the management of data quality and governance, the company announced at its annual Informatica World conference in Las Vegas.

The agents can help discover data, understand data based on business semantics, create data pipelines to collect, integrate, and clean the datasets required, generate insights from datasets, generate a data model for master data, and generate ETL or  ELT pipelines, VP of product management Gaurav Pathak told Infoworld.

“Before the introduction of Claire Agents, each of the capabilities had to be carried out manually via code or through guided systems,” Pathak said. “Despite the use of guided systems earlier, enterprise users were required to set up business logic, perform software development lifecycle (SDLC) tasks, and maintain the workflows or applications,” Pathak added.

Data cleaning and augmentation are never-ending tasks for many enterprises, said Amalgam Insights chief analyst Hyoun Park, and automation could help them finally get on top of things.

The first of the new agents will tackle tasks including data quality, data discovery, data lineage, data ingestion, ELT, and data exploration, but Informatica customers will have to do things manually for a little longer: The company doesn’t expect to offer a preview of the new agents until the Fall.

Support for Anthropic’s MCP and Google’s A2A protocols

Informatica said that Claire Agents can act as an endpoint for Google’s recently released Agent2Agent (A2A) protocol, and as both client and server for Anthropic’s Model Context Protocol (MCP). Salesforce, Workday, SAP, MongoDB, and ServiceNow have adopted the A2A protocol, while MCP is an increasingly popular choice among other data management and analytics software providers.

As MCP clients, Claire Agents can use the MCP server implementations in third-party services such as catalogs to discover and explore metadata. As an MCP server, Claire exposes agent capabilities so that other MCP clients can access the agents and other IDMC capabilities, Pathak said. These capabilities include creating and managing data Integration pipelines, creating and enriching master data management (MDM) business entities, and monitoring IDMC workflows, he said.

There have been some concerns raised about challenges managing the security of MCP; Pathak said that Claire will use the security context of the user credentials provided to the API for MCP implementation, so it remains compliant with the security layers in the customer environment.

Building and orchestrating agents

AI Agent Engineering, Informatica’s service within IDMC for building, connecting, and managing intelligent multi-agent systems, will be available globally later this year.

The service provides a unified no-code environment for technical and non-technical users to build and orchestrate agents across ecosystems like AWS, Azure, Databricks, Google Cloud, Salesforce, and Snowflake among others, Sumeet Agarwal, VP of product management at Informatica, told InfoWorld.

“You can build a wide range of custom AI agents-from employee onboarding assistants and supply chain resilience agents that reroute orders, to marketing personalization agents that coordinate campaigns across CRM and ad platforms,” Pathak said, adding that pre-built templates for common scenarios like chatbots, Q&A bots, data agents, and supervisor/worker patterns among others were available.

The Futurum Group’s lead of data and analytics practice, Bradley Shimmin, said that the agent building capability will be welcomed by enterprises already subscribed to IDMC as it will speed time to market and provide operational support relating to governance and security.

IDC research vice president Stewart Bond said AI Agent Engineering’s agent orchestration is likely to be of more value to enterprises than its agent building capabilities.

“Given that many agents are coming from many vendors across multiple functions, orchestration becomes key. Application and data integration platforms are a natural ‘middleware’ solution for this orchestration,” Bond explained.

AI Agent Engineering is expected to be available globally in fall of 2025.

The adoption challenge

Informatica is far from the only vendor rolling out agentic capabilities for data management.

IBM and SAP have already made some moves towards cleaning up data with agents, said Park.

“Amalgam Insights expects that every data integration company will announce agents this year that assist with data quality, deduplication, lineage, and cleansing — but the devil will be in the details: What percentage of data can the agent support? Can semi-structured and unstructured data be cleansed? Will the agent work with all major enterprise data sources and destinations?” he said.

IDC’s Bond said that getting agents into the market is a start, but helping customers with adoption will be an altogether different challenge.

“These agents will significantly change how people work, and software vendors will also need to be change agents in their customer environments. Training, coaching, and support will be critical to success for both the customer and the vendor,” he said, adding that Informatica will need to invest in new skills in customer success teams and in enabling services partners.

Bond pointed to Informatica’s own Claire Copilot as an example of how long the timeline can be for enterprise adoption.

“We saw Claire Copilot last year at this time, and it is just being made generally available. This demonstrates the reality of how complex these technologies are to work with and package in a way that they are adaptable and scalable in the enterprise,” he said.

The familiar formatted string, or f-string, feature in Python provides a convenient way to print variables as part of a string. But it doesn’t let you interact with the way strings are created from those variables. It’s hard, if not impossible, to do things like inspect each variable as it’s inserted into the string and take some action based on what it is.

Python 3.14 has a new feature called the template string, or t-string, type. A t-string superficially resembles an f-string, but it’s designed to do something very different. Instead of just printing the string with the variables interpolated into it, a t-string lets you process both the string elements and the interpolated variables as separate components, and construct whatever kind of string you like from that.

A basic template string

Template strings look a lot like f-strings. The only difference is the use of t instead of f to define the string:

ame = "Davis"
template = t"Hello, {name}"

n

If this were a conventional f-string, we could print(template) and get Hello, Davis as the output. But if we try printing a t-string, we don’t get a string. Instead, we get a Python object representation:

Template(strings=('Hello ', ''), interpolations=(Interpolation('Davis', 'name', None, ''),))

This is because t-strings aren’t meant to be printed directly. Instead, we do something with their contents by applying a function or class method.

A t-string object contains different sub-objects we can iterate through, which represent the contents of the t-string:

• The strings object contains all the static strings in the original template—in this case, the "Hello, " before the variable and the empty string "" after the variable.
• The interpolations object contains all the interpolations of the different variables in the t-string. Each is a separate Interpolation object with data about its value, the expression used to create it, and other useful details.

If you iterate through the template directly (for item in template:) you would get each element in the template in turn: the string "Hello, ", the Interpolation object shown above, and the string "". This makes it easy to assemble a new string from the elements of a t-string.

Using a template string

Again, the point of a template string isn’t to print it as is, but to pass it to a function that will handle formatting duties. For instance, a simple template string handler to render each variable’s string representation in upper case might look like this:

from string.templatelib import Template, Interpolation
def t_upper(template: Template):
    output = []
    for item in template:
        if isinstance(item, Interpolation):
            output.append(str(item).upper())
        else:
            output.append(item)
    return "".join(output)

If we ran t_upper() on the above template, we would get Hello, DAVIS as the output.

Note that we have an import line in this code:

from string.templatelib import Template, Interpolation

string.templatelib is a new module in the standard library for Python 3.14 that holds the types we need: Template for the type hint to the function, and Interpolation to check the elements we iterate through.

However, we don’t need string.templatelib to make template strings. Those we can construct just by using the t-string syntax anywhere in our code.

A useful template string example

For a better example of how useful and powerful template strings can be, let’s look at a task that would be a good deal more difficult without them.

You’re probably familiar with HTML sanitization, which removes potentially harmful elements from HTML content so that only safe HTML gets displayed on the web page. Many template engines exist to do this. We can accomplish the same with template strings and more besides:

from string.templatelib import Template, Interpolation
import urllib.parse
import html

def clean(input:Template):
    output = []
    inside_tag = False
    for item in input:
        if isinstance(item, Interpolation):
            escape = urllib.parse.quote if inside_tag else html.escape
            out_item = escape(str(item.value))
        else:
            for l in item:
                if l in (""):
                    inside_tag = not inside_tag
            out_item = item
        output.append(out_item)
    return "".join(output)

name=""
print(clean(t'Hello, {name}'))

The function clean() takes in a template string and cleans it in such a way that any HTML brackets ( and > ) will be changed to harmless literals ( < and >). The surrounding strings in the template string aren’t modified.

To do this, the clean() function performs three different kinds of processing:

1. If the function encounters a conventional string, which includes HTML we do want to render, that string is added to the output as is. It also keeps track of whether or not we are, at that point, inside an HTML tag. (The algorithm used for this isn’t very sophisticated; this is just an example.)
2. If the function encounters an interpolation, and we’re inside an HTML tag (for instance, in the portion of the template), it uses urllib.parse.quote to escape the string. This ensures that the string can be included between quotes inside a tag without mangling anything, and that the string is URL-safe.
3. If the function encounters an interpolation outside an HTML tag, it uses a different function to escape it (html.escape). This also escapes HTML entities but handles quotes differently, and doesn’t bother ensuring the output is URL-safe (since we don’t need URL safety outside of tags).

Run this code and you’ll get the following output:

Hello, 

Note how spaces in the URL version of the string are escaped, but spaces in the text itself are not. This kind of granular processing of each variable cannot be done easily in an f-string, if at all.

The advantage of t-strings

One big advantage to using t-strings: You can pass the t-string to different processing functions. The same t-string can be used to generate different kinds of output simply by changing the function applied. This way, creating the t-string and rendering it to text can be completely separate operations. At the same time, the rendering can be done with full access to the original input, including details about each interpolated variable.

I have many good memories of attending the annual Borland Conference, back when Borland was still a high-flying tech company and developer conferences felt like rock concerts for nerds. I was an Object Pascal developer, so Delphi was my tool of choice. The conferences in the late 1990s and early 2000s were magical. There were many great presentations, and every year brought a new release of Delphi with amazing new features. Capabilities most of you take for granted, like code completion and IntelliSense, were mind-bending to us when shown during the big keynotes. 

But it was a feature of the then-new JBuilder—the first real IDE for Java development—that made the biggest impression on me. It was the Rename refactoring. Kate Stone, the lead architect for JBuilder, got up on stage, selected a variable name that was used throughout her application, and in one simple action, changed the name of that variable all at once across the entire code base. 

Now, you’re probably thinking, “Big deal. I do that all the time.” But back then, it was revolutionary—some serious black magic. My eyes were as wide as saucers, and I thought I’d seen water turned to wine. Kate went on to discuss other “refactorings” such as “Extract Method” and “Update Parameter List,” which at the time sounded like magic spells. 

But of course, refactorings in the IDE are old hat. The concepts in Martin Fowler’s seminal book Refactoring are now mainstream and understood by most developers. Most of us use IDE-based refactorings today. But it seems strange that the idea of refactoring—i.e., improving the code without changing its function—is relatively new. The book was only published in 1999. You don’t need IDE tooling to refactor, but it sure makes it easier. 

Refactoring is important, and all of Fowler’s refactorings are useful. But here are the three that will have the biggest impact on your code.

Extract Method

If I had to rely on only one refactoring, it would be Extract Method, because it is the best weapon against creating a big ball of mud. The single best thing you can do for your code is to never let methods get bigger than 10 or 15 lines. The mess created when you have nested if statements with big chunks of code in between the curly braces is almost always ripe for extracting methods. One could even make the case that an if statement should have only a single method call within it. 

I’d go so far as to say that you aren’t done refactoring your code until there is no point in applying the Extract Method refactoring anywhere. Or put a different way, if you can extract a method, you should do so in every case. Some complain that this results in tons of small methods, to which my response is “Yes, exactly.” Tons of small methods that are well named (see below) and that do only one thing are a thing of beauty and a joy forever. Extract methods until you get there.

Rename Variable/Method/Class

It’s a common motif that naming things is hard. It’s common because it is true. We all know it. We all struggle to name things well, and we all read legacy code with badly named variables, methods, and classes. Often, you name something and you know what the subtleties are, but the next person that comes along does not. Sometimes you name something, and it changes meaning as things develop. But let’s be honest, we are going too fast most of the time and as a result we name things badly. 

This is where the Rename refactor comes in. Being able to rename a variable easily should encourage you to do so. If you realize a name is bad, change it to something better and more precise. And because you only have to change the name once to change it everywhere, don’t be afraid to use a name that is a bit longer and clearer. 

RecordNumber beats RecNo and CustomerRecordNumber beats RecordNumber. CustomerNumberCannotBeZero is a better name for a boolean than doing CustNo > 0. Naming is hard, but if you take the time, you can give everything a proper name. And if you realize you need a different name, having the Rename refactoring available should embolden you to freely and brazenly name things clearly and precisely. Clear and expressive names are always winners.

Extract Variable

All too often, we get into a hurry when we are coding. For instance, we’ll type something like this:

If CalculateInterestRate(GatherAllInputs()) > 0.6 {
  …
}

In other words, we pass a function result directly into another function as part of a boolean expression. This is… problematic. First, it’s hard to read. You have to stop and think about all the steps. Second, and more importantly, it is hard to debug. If you set a breakpoint on that line, it is hard to know where the code is going to go next. 

However, if you extract all that code out into something more readable and debuggable, you have a much better result:

const AllTheInputs = GatherAllInputs();
const CustomerInterestRate = CalculateInterestRate(AllTheInputs);
const CustomerInterestRateIsHighEnough = CustomerInterestRate > 0.6;
If CustomerInterestRateIsHighEnough {
  …
}

That’s clean, lovely code that is easy to read and easy to debug. It’s also easy to “write” with the Extract Variable refactoring tool. 

And to those of you who say that’s too much typing, I say, “Laziness is not a career-enhancing move.”

Extract Method, Rename Variable/Method/Class, and Extract Variable are not the only refactoring tools in the toolbox, but they are the most useful. They are the ones that provide the most benefit. If I had to choose only one to use, I’d pick Extract Method, because it is the strongest defense against the common problem (temptation?) of sprawling methods. 

In the end, refactoring is the key to great code. Modern IDEs make it easy to do, so you have no excuse not to create code that your team members and subsequent maintainers will thank you for.

Scala 3.7.0, the latest version of the object-oriented, functional language with JVM, native, and JavaScript runtimes, stabilizes named tuples and brings a “crucial” fix that enhances its compatibility with Android.

Scala 3.7.0 was announced May 7. Installation instructions can be found at scala-lang.org.

In Scala 3.7.0, named tuples, introduced as experimental in Scala 3.5 in August 2024, become stable. Named tuples provide a convenient way to return multiple results from a function or to model the data using tuples, while allowing developers to use meaningful names for its fields, Wojciech Mazur of VirtusLab wrote in a blog post announcing the release. 

Meanwhile, a compiler fix in Scala 3.7.0 enhances the language’s compatibility with the Android platform. Developers had faced issues when compiling Scala 3 code for Android due to the Android Runtime (ART) enforcing stricter type constraints on lambdas than the standard JVM. ART requires that the return type of a Single Abstract Method (SAM) interface be a primitive type or explicitly boxed, a condition not required by the JVM. The update modifies the Scala compiler to box the return type of native instantiated methods when the SAM’s return type is not primitive.

Also in Scala 3.7.0, case classes now may have dependent fields, thus boosting expressiveness and type safety. This allows fields within a case class to depend on other constructor parameters via path-dependent types. Other improvements in Scala 3.7.0 include the following:

• Dependencies can be brought to an already-running REPL session via the :jar command.
• For library maintainers, Scala 3.7.0 stabilizes the @publicInBinary annotation, which was introduced experimentally in Scala 3.4. This annotation ensures binary compatibility when inline methods access non-public members and prevents generation of redundant accessors required by Scala’s inlining mechanism.
• Scala 3.7.0 introduces the concept of preview features, which are fully implemented and SIP-approved (Scala Improvement Process), but potentially subject to small refinements before becoming stable. The first preview feature is for comprehension improvements, which was added to Scala 3.6.0 as experimental.

Java Development Kit (JDK) 25, a planned long-term support release of standard Java due in September, has added three more features, bringing the total number to nine. Scoped values, a vector API, and a key derivation function API, all of which have been previewed or incubated in previous versions of standard Java, are now part of the JDK 25 release.

JDK 25 comes on the heels of JDK 24, a six-month-support release that arrived March 18. As a long-term support (LTS) release, JDK 25 will get at least five years of Premier support from Oracle. JDK 25 is due to arrive as a production release on September 16, following rampdown phases in June and July and two release candidates planned for August. The most recent LTS release was JDK 21, which arrived in September 2023.

Early access builds of JDK 25 can be downloaded from jdk.java.net. The features previously slated for JDK 25 include structured concurrency, flexible constructor bodies, module import declarations, compact source files and instance main methods, stable values, and removal of the 32-bit x86 port.

Scoped values, to be previewed for a fifth time, allows a method to share immutable data with its callees within a thread and with child threads. Scoped values are easier to reason about than thread-local variables, according to the OpenJDK JDK Enhancement Proposal (JEP). They also have lower space and time costs, especially when used together with virtual threads and structured concurrency. Goals of the plan include ease of use, comprehensibility, robustness, and performance. The scoped values API was proposed for incubation in JDK 20, proposed for preview in JDK 21, and subsequently refined for JDK 22 through JDK 24. The feature will be finalized in JDK 25, with one change: the ScopedValue.orElse method no longer accepts null as its argument.

The vector API is designed to express vector computations that reliably compile at runtime to optimal vector instructions on supported CPUs, thus achieving performance superior to equivalent scalar computations. The API will be incubated for the 10th time in JDK 25, after having been incubated in every release dating back to JDK 16. Two notable changes are featured in the JDK 25 implementation of the API. First, the implementation now links to native mathematical-function libraries via the Foreign Function and Memory API rather than custom C++ code inside the HotSpot JVM, thus improving maintainability. Second, addition, subtraction, division, multiplication, square root, and fused multiply/add operations on Float16 values now are auto-vectorized on supporting x64 CPUs.

The key derivation function API provides for functions that are cryptographic algorithms for deriving additional keys from a secret key and other data. One of the goals of the API is enabling applications to use key derivation function algorithms such as the HMAC-based Extract-and-Expand Key Derivation Function and Argon2. Other goals include allowing security providers to implement key derivation function algorithms in either Java code or native code, and enabling the use of key derivation functions in key encapsulation mechanism implementations such as ML-KEM, in higher level protocols such as Hybrid Key Exchange in TLS 1.3, and in cryptographic schemes such as Hybrid Public Key Encryption. The API will be finalized in JDK 25 after being previewed in JDK 24.

Structured concurrency was previewed previously in JDK 21 through JDK 24, after being incubated in JDK 19 and JDK 20. Structured concurrency treats groups of related tasks running in different threads as single units of work. This streamlines error handling and cancellation, improves reliability, and enhances observability, the proposal states. The primary goal is to promote a style of concurrent programming that can eliminate common risks arising from cancellation and shutdown, such as thread leaks and cancellation delays. A second goal is to improve the observability of concurrent code. JDK 25 introduces several API changes. In particular, a StructuredTaskScope is now opened via static factory methods rather than public constructors. Also, the zero-parameter open factory method covers the common case by creating a StructuredTaskScope that waits for all subtasks to succeed or any subtask to fail.

Flexible constructor bodies was previewed in JDK 22 as “statements before super(…)” as well as in JDK 23 and JDK 24. The feature is intended to be finalized in JDK 25. In flexible constructor bodies, the body of a constructor allows statements to appear before an explicit constructor invocation such as super (…) or this (…). These statements cannot reference the object under construction but they can initialize its fields and perform other safe computations. This change lets many constructors be expressed more naturally and allows fields to be initialized before becoming visible to other code in the class, such as methods called from a superclass constructor, thereby improving safety. Goals of the feature include removing unnecessary restrictions on code in constructors; providing additional guarantees that state of a new object is fully initialized before any code can use it; and reimagining the process of how constructors interact with each other to create a fully initialized object.

Module import declarations, which was previewed in JDK 23 and JDK 24, enhances the Java language with the ability to succinctly import all of the packages exported by a module. This simplifies the reuse of modular libraries but does not require the importing code to be in a module itself. Goals include simplifying the reuse of modular libraries by letting entire modules be imported at once; avoiding the noise of multiple type import-on-demand declarations when using diverse parts of the API exported by a module; allowing beginners to more easily use third-party libraries and fundamental Java classes without having to learn where they are located in a package hierarchy; and ensuring that module import declarations work smoothly alongside existing import declarations. Developers who use the module import feature should not be required to modularize their own code.

Compact source files and instance main methods evolves the Java language so beginners can write their first programs without needing to understand language features designed for large programs. Beginners can write streamlined declarations for single-class programs and seamlessly expand programs to use more advanced features as their skills grow. Likewise, experienced developers can write small programs succinctly without the need for constructs intended for programming in the large, the proposal states. This feature, due to be finalized in JDK 25, was previewed in JDK 21, JDK 22, JDK 23, and JDK 24, albeit under slightly different names. In JDK 24 it was called “simple source files and instance main methods.”

Stable values are objects that hold immutable data. Because stable values are treated as constants by the JVM, they enable the same performance optimizations that are enabled by declaring a field final. But compared to final fields, stable values offer greater flexibility regarding the timing of their initialization. A chief goal of this feature, which is in a preview stage, is improving the startup of Java applications by breaking up the monolithic initialization of application state. Other goals include enabling user code to safely enjoy constant-folding optimizations previously available only to JDK code; guaranteeing that stable values are initialized at most once, even in multi-threaded programs; and decoupling the creation of stable values from their initialization, without significant performance penalties.

Removal of the 32-bit x86 port involves removing both the source code and build support for this port, which was deprecated for removal in JDK 24. The cost of maintaining this port outweighs the benefits, the proposal states. Keeping parity with new features, such as the foreign function and memory API, is a major opportunity cost. Removing the 32-bit x86 port will allow OpenJDK developers to accelerate the development of new features and enhancements.

Separate from the official feature list, JDK 25 also brings performance improvements to the class String, by allowing the String::hashCode function to take advantage of a compiler optimization called constant folding. Developers who use strings as keys in a static unmodifiable Map should see significant performance boosts, according to a May 1 article on Oracle’s Inside Java web page.

Another feature that could find a home in JDK 25 is primitive types in patterns, instanceof, and switch, which was previewed in JDK 24. Java turns 30 years old on May 23.

Event-driven architecture (EDA) has long been a foundational piece of scalable, real-time systems. This includes things like payment processing and fraud detection, IoT and logistics, and AI-powered applications. Today, with AI, the value of streaming data is more apparent than ever. Despite this, the operational complexity of managing platforms like Apache Kafka has often slowed adoption or limited its reach.

Kong’s new Event Gateway is designed to simplify and secure the adoption of event-driven architecture by giving platform teams and developers the ability to expose Kafka as Kong-managed APIs and services in the same place where you’d use Kong to manage API, AI, and service mesh deployments. This allows you to bring all of the benefits of your Konnect API Platform to the event streaming universe, using the Event Gateway and Konnect platform to enforce policies for security, governance, and cost controls across your entire API, AI, and event streaming estate.

Here are four ways the Event Gateway helps organizations unlock the full potential of their Kafka investments.

Manage Kafka event streams in the same way you manage your APIs

Event Gateway enables platform teams to expose Kafka topics as HTTP APIs (such as REST or server-sent events APIs) or as services that communicate over the native Kafka protocol. Whichever route you choose, you can use Kong plugins and policies to bring the same level of security, reliability, and governance to your Kafka estate as you would with your Kong-managed API and AI estates. 

Reduce Kafka infrastructure costs with virtual clusters and topics

Kafka is great for transmission of business critical data at massive scale without sacrificing performance—essential for any real-time initiatives. However, Kafka can present challenges pertaining to client isolation and access control to data at the event level. Today, Kafka often requires infrastructure and platform teams to often implement (and pay for) duplicate topics, partitions, and data to effectively segment subsets of data.

Kong can reduce overall infrastructure costs related to Kafka through virtual clusters and topics. Kong’s virtual clusters and concentrated topics functionality will allow for scalable and efficient logical isolation—all managed by Kong—which cost much less to run, ultimately allowing you to drive greater and greater Kafka cost efficiencies as you expand the footprint of your eventing platform.

Strengthen your cloud security posture

Moving to cloud and vendor-managed versions of Kafka enables EDA teams to focus on building event-driven architectures without the operational burden of managing Kafka infrastructure. However, while the value of the cloud is clear, many organizations still have concerns about PII (personally identifiable data) and other sensitive data running through vendor cloud environments.

The Kong Event Gateway can help with this by enforcing encryption at the gateway layer, within your private network, so that data in your cloud environment is encrypted.

Turn event streams into real-time data products

With Event Gateway, organizations can expose Kafka event streams as structured, reusable API data products.

The protocol mediation approach opens up the value of real-time data in Kafka to developers and customers that don’t want to, or can’t, set up their applications as Kafka clients. Kong Event Gateway customers will be able to expose access to this real-time data as REST APIs and server-sent events APIs to ensure that they can meet developers, partners, and customers where they are.

Event Gateway will be available as part of Kong Konnect, the unified API platform built to help organizations power API-driven innovation at scale with performance, security, and governance across all service types. With Event Gateway, Kong supports the entire API life cycle with one end-to-end platform, enabling teams to discover, observe, and govern event APIs alongside large language model (LLM) APIs, REST APIs, and any other supported service type in the Kong platform.

As organizations shift toward real-time, API-first architectures, Kong helps them manage that transformation securely and efficiently. By bringing event streams into your API Platform, Event Gateway allows teams to move faster, reduce operational burden and build more responsive, data-driven applications.

For a full list of features and documentation, visit the Kong Event Gateway product page.

Marco Palladino is the CTO and co-founder of Kong.

—

New Tech Forum provides a venue for technology leaders—including vendors and other outside contributors—to explore and discuss emerging enterprise technology in unprecedented depth and breadth. The selection is subjective, based on our pick of the technologies we believe to be important and of greatest interest to InfoWorld readers. InfoWorld does not accept marketing collateral for publication and reserves the right to edit all contributed content. Send all inquiries to doug_dineley@foundryco.com.

Google is expected to unveil a new AI agent aimed at helping software developers manage tasks across the coding lifecycle, including task execution and documentation.

The tool has reportedly been demonstrated to employees and select external developers ahead of the company’s annual I/O conference, scheduled for May 20 in Mountain View, California, according to a report by The Information.

Generative AI is driving a significant paradigm shift in how developers write code, develop software applications, reduce technical debt, and improve quality. GenAI isn’t just writing code, and there are opportunities for the entire agile development team to use LLMs, AI agents, and other genAI capabilities to deliver improvements across the software development lifecycle.

Improving requirements gathering and the quality of agile user stories is becoming a significant opportunity for generative AI. As developers write code faster and more efficiently, deeper agile backlogs with more user stories and stronger acceptance criteria are needed.

How AI copilots increase developer productivity

Developers use genAI to transform software development, including generating code, performing code reviews, and addressing production issues. BairesDev reports that 72% of developers are now using genAI capabilities, and 48% use genAI tools daily.

AI copilots and genAI code generators are impacting productivity significantly. A recent report based on field experiments with software developers at Microsoft and Accenture found that using a coding assistant caused a 26% increase in the weekly number of completed tasks, a 13% increase in the number of code commits, and a 38% increase in the number of times code was compiled.

Developers are also reporting productivity impacts. According to DORA’s 2024 State of DevOps Report, more than one-third of respondents described their observed productivity increases as either moderate (25%) or extreme (10%) in magnitude.

Why requirements gathering is the new bottleneck

As agile development teams become more proficient with code generators, the velocity and quality of requirements gathering and agile user stories must increase. Additionally, the structure of agile user stories and the completeness of their acceptance criteria have become more important as developers use them to prompt AI agents to develop, test, and document code.

“In a world where copilots are writing code, planning will take on a much more important role, and the requirements documents must become more detailed than the days when teams sat together in the same room,” says David Brooks, SVP of evangelism at Copado. “Business analysts will use genAI to summarize feature requests and meeting transcripts to capture all of the inputs and help prioritize based on the level of need. GenAI can then write the first draft or review the human-written draft for completeness to ensure that it aligns with the company’s format.”

The key to success is engaging end-users and stakeholders in developing the goals and requirements around features and user stories. This engagement must go beyond the usual responsibilities of agile product owners; software developers should engage stakeholders in understanding objectives, discussing risks, and devising experiments.

How genAI improves requirements gathering

Chris Mahl, CEO of Pryon, says genAI is reshaping requirements gathering from a documentation exercise to a collaborative discovery process. “Product owners now use AI to generate initial requirement drafts from stakeholder interviews, then refine them through feedback cycles. The business analyst role is evolving from documentation specialist to AI orchestrator, and success requires proficiency in prompt engineering and framing business problems to elicit optimal AI responses.”

The business analyst partners with the agile product owner and team lead to oversee the end-to-end requirements process. They are especially valuable for more technical agile teams working on microservices, integrations, and data pipelines. User stories in these technical deliverables have significant non-functional acceptance criteria, and testing often requires building synthetic test data to validate many use cases.

Mahl adds, “The technology excels at translating business needs into technical specifications and vice versa, bridging communication gaps. Critical thinking becomes essential as analysts must validate AI-generated content for accuracy and business alignment.”

Critical thinking is a crucial skill set to develop as more requirements, code, and tests are developed using genAI tools. Agile developers must learn how to ask questions, include the most important details in prompts, and validate the completeness and accuracy of genAI responses.

Business analysts and product owners have new tools to accelerate translating conversations, brainstorming, and other meeting notes into ideas, epics, and features. Tameem Hourani, principal at RapDev, says, “By joining conference calls, analyzing them, summarizing them, and extracting takeaways from them, you can suddenly groom backlogs for epics of all sizes.”

How genAI supports rapid prototyping and faster delivery

A second opportunity for agile development teams is to use genAI to reduce cycle times, especially around proof of concepts and iterating through end-user experiences. GenAI should help agile teams incorporate more design thinking practices and increase feedback cycles.

“GenAI tools are fundamentally shifting the role of product owners and business analysts by enabling them to prototype and iterate on requirements directly within their IDEs rapidly,” says Simon Margolis, Associate CTO at SADA. “This allows for more dynamic collaboration with stakeholders, as they can visualize and refine user stories and acceptance criteria in real time. Instead of being bogged down in documentation, they can focus on strategic alignment and faster delivery, with AI handling the technical translation.”

One opportunity is in the development of low-code platforms that can generate applications from genAI prompts. Platforms like Adobe, Appian, Pega, Quickbase, and SAP use genAI tools to accelerate the prototyping and development of apps and agents.

Use genAI tools to focus more time on human innovation

Product owners and business analysts have more significant roles than grooming backlogs and documenting requirements. Their strategic importance lies in promoting innovations that matter to end users, delivering business value, and creating competitive advantages. They must also adhere to devops non-negotiable standards, steer agile development teams toward developing platform capabilities, and look for ways to address technical debt.

“GenAI excels at aligning user stories and acceptance criteria with predefined specs and design guidelines, but the original spark of creativity still comes from humans,” says Ramprakash Ramamoorthy, director of AI research at ManageEngine. “Analysts and product owners should use genAI as a foundational tool rather than relying on it entirely, freeing themselves to explore new ideas and broaden their thinking. The real value lies in experts leveraging AI’s consistency to ground their work, freeing them to innovate and refine the subtleties that machines cannot grasp.”

GenAI can enable transformation capabilities when organizations look beyond productivity drivers. Agile development teams should use genAI to accelerate and improve requirements gathering and writing agile user stories. GenAI provides the opportunity to streamline these tasks and improve quality, leaving more time for product owners and business analysts to increase focus on where technology provides lasting value to their organizations.

In the early 2010s, enterprises enthusiastically embraced the “cloud first” ethos. Between 2010 and 2016, businesses aggressively migrated applications and data to the public cloud, spurred on by promises of lower costs, greater efficiency, and unbeatable scalability. However, this movement quickly revealed significant shortcomings.

Many organizations transferred applications and workloads to the cloud without comprehensive planning, failing to account for long-term financial implications, data complexities, and performance requirements. Today, we’re witnessing enterprises repatriate workloads back to on-premises or hybrid environments due to unexpected costs and a mismatch of capabilities.

Like the cloud first frenzy, enterprises are barreling toward the next big wave: the “AI first” mandate. This rush to implement artificial intelligence technologies without a disciplined, strategic framework is eerily familiar. If history is any indication, failing to plan carefully will again lead to substantial mistakes, wasted budgets, and underwhelming results.

The cloud-first cautionary tale

The drawbacks of the cloud-first movement weren’t apparent immediately. In theory, moving workloads to the public cloud seemed like an ideal solution to outdated infrastructure, and it gave the added promise of cost savings. However, these migrations were often driven by FOMO (fear of missing out) rather than practicality. Organizations moved applications and data without optimizing them for public cloud platforms, overlooking aspects like workload performance, governance, and comprehensive cost analysis.

Years later, many companies discovered that hosting these workloads in the cloud was far more expensive than initially anticipated. Costs ballooned due to unoptimized architectures, excessive egress fees, and persistent underestimation of cloud pricing models. That lesson is now painfully remedied by a return to hybrid or completely on-premises systems, but not without significant cost and effort.

What went wrong during the cloud-first boom wasn’t just flawed execution but a fundamental lack of strategic planning. Instead of understanding which workloads would genuinely benefit from the cloud and optimizing them for that environment, enterprises treated cloud adoption as a blanket mandate. As businesses face the AI-first mandate, they do so under similar circumstances: enticing technology, unclear benefits, and an overwhelming urgency to act.

Is AI the right tool?

AI is undeniably transformative. It has the potential to enhance decision-making, automate processes, and open up unprecedented business opportunities. However, companies are indiscriminately layering AI into systems and methods without carefully evaluating its suitability or ROI. Enterprises may use AI to solve problems it isn’t well-suited to solve, or deploy it at scales that far outstrip the ability of the infrastructure to support it.

Worse yet, some organizations are tackling AI projects without fully understanding their costs or the data complexities involved, especially in view of new data privacy and ethics regulations. Much like the cloud rush, companies risk building expensive, poorly optimized AI systems that deliver little value or introduce risk. The AI-first movement feels uncomfortably reminiscent of the early days of cloud computing.

If there’s one lesson to learn from the cloud-first era, it is that strategic planning is the backbone of successful technology adoption. Before adopting AI to keep up with competitors, organizations should assess their unique business goals and determine whether AI is truly the right solution. Not every business problem needs AI. Leaders should ask hard questions:

• What specific outcomes are we trying to achieve with AI?
• Are there simpler, more cost-effective solutions available?
• How will success be measured?

Many of my clients are taken aback when I raise these questions, which is a bit concerning. I’m there as an AI consultant; I could easily keep my mouth shut and collect my fees. I suspect other AI architects are doing just that. Enterprises need to realize that the misuse of this technology can cost five to seven times more than traditional application development, deployment, and operations technologies. Some businesses will likely make business-ending mistakes. However, these questions are fundamental to the problems to be solved and the value of the solutions that we leverage, whether AI or not.

The elements of a successful plan

Rather than embark on large-scale AI implementations, start with smaller, controlled pilot projects tailored to well-scoped use cases. Such projects evaluate effectiveness, model costs, and identify potential risks. AI technology is evolving rapidly. Deploying today’s cutting-edge models or tools doesn’t guarantee long-term relevance. Enterprises should build adaptable, modular systems that can grow with the technology landscape and remain cost-effective over time. As you plan a pilot project, keep in mind the following:

• Prepare your data. AI systems are only as good as the data they rely on. Many enterprises hastily jump on AI initiatives without first evaluating their data repositories. Key data-readiness steps include ensuring data accuracy, consistency, and quality. Finally, build pipelines that ensure AI systems can efficiently access and process the data needed.
• Be realistic. Like cloud services, AI can have hidden costs, from computing resources to training large data sets. Enterprises need to analyze the total cost of ownership and the feasibility of deploying AI systems based on current resources and infrastructure rather than relying on optimistic assumptions.
• Acquire the skills. Throwing tools at a problem doesn’t guarantee success. AI requires knowledgeable teams with the skills to design, implement, and monitor advanced systems. Enterprises should invest in upskilling workers, create cross-functional AI teams, and hire experts who can bridge the gap between business needs and AI capabilities.
• Implement governance. AI introduces ethical, security, and operational risks. Organizations need to establish clear structures to monitor AI system performance and mitigate risks. If AI involves sensitive data, you’ll need to establish governance standards for data privacy and compliance. Ensure transparency around how AI makes decisions, and prevent overuse or misuse of AI technology.

The AI-first movement holds enormous promise, but enthusiasm puts us at risk of repeating the costly mistakes of the cloud-first era. With AI, the lesson is clear: Decision-makers must avoid knee-jerk reactions and focus on long-term success through careful strategy, planning, and disciplined execution. Businesses that take a thoughtful, deliberate approach will likely lead the AI-driven future while others scramble to undo costly, short-sighted implementations. The time to plan is now. As we’ve seen, “move first, think later” rarely works out.