devopsy.kinsta.cloud

Category: Blogs

Chronosphere Streamlines Management of Log Data to Reduce Costs

Chronosphere today added additional capabilities to its log management platform that enable DevOps teams to both reduce costs and surface more actionable insights.

Alok Bhide, head of product innovation for Chronosphere, said Chronosphere Logs 2.0 provides DevOps teams with more granular control over how log data is collected and stored. The overall goal is to make it simpler for DevOps teams to not only leverage analytics to identify which log data is actually being used but also more easily correlate it with metrics, events and traces, he added.

Additionally, Chronosphere has added a Logs Quotas tool that enables DevOps teams to enforce budget restrictions on individual teams all the way down to specific datasets.

Most DevOps teams are already being overwhelmed by the amount of telemetry data being collected, an issue that will only become more challenging to manage as more cloud-native and artificial intelligence (AI) applications are deployed in production environments.

There is, of course, no shortage of observability platforms, but as IT environments become more complex, the need for tools that go well beyond simple monitoring of pre-defined metrics to troubleshoot applications has become a lot more pressing. The challenge is observability platforms collect data at levels of scale that from a cost perspective quickly add up. As a result, managing telemetry data has become a significant challenge. Unfortunately, most DevOps teams are not going to be able to hire someone to optimally manage the flow telemetry data. Instead, that needs to be a core capability of the observability platform.

Less clear in the longer term is to what degree observability will become a task assigned to an artificial intelligence (AI) agent rather than a DevOps engineer. There is no doubt DevOps engineers will need to review the findings of an AI agent that has investigated an incident, but much of the tedious effort required to sort through metric, events, logs and traces should become increasingly automated. Each DevOps engineering team will then need to decide how comfortable they are allowing another set of AI agents to automatically remediate issues as they are uncovered, noted Bhide.

In the meantime, organizations have never been more dependent on software than they are today, but even as the number of applications being deployed increases, the size of the DevOps teams tasked with maintaining them continues to remain relatively stagnant. In fact, in an AI era where more applications are expected to be deployed in the next few years than the entire last decade, supporting all those applications will require an ability to investigate and, if necessary, remediate anomalies within minutes of being discovered. Legacy monitoring tools were never intended to provide forensics insights in near real time.

Of course, convincing business leaders to invest in observability platforms can be a challenge. DevOps teams need to be certain that the cost of storing massive amounts of telemetry does not outweigh the benefits. After all, no matter how many issues an observability prevents, someone in the finance team will still be closely monitoring the cost of a platform that over time only continues to grow.

June 24, 2025
Five Great DevOps Job Opportunities

DevOps.com is now providing a weekly DevOps jobs report through which opportunities for DevOps professionals will be highlighted as part of an effort to better serve our audience.

Our goal in these challenging economic times is to make it just that much easier for DevOps professionals to advance their careers.

Of course, the pool of available DevOps talent is still relatively constrained, so when one DevOps professional takes on a new role, it tends to create opportunities for others.

The five job postings shared this week are selected based on the company looking to hire, the vertical industry segment and naturally, the pay scale being offered.

We’re also committed to providing additional insights into the state of the DevOps job market. In the meantime, for your consideration.

The Job Network

CLS US Services
Woodbridge, NJ
DevOps Engineer
$179,982 to $200,000

LinkedIn

Agiloft
Remote
Staff DevOps Engineer
$170,000 to $190,000

SimplyHired.com

Liberty Mutual
Portsmouth, NH
Senior Infrastructure Engineer
$159,300 to $201,900

Dice.com

Eli Lilly and Company
Indianapolis, IN
ASO IDS DevOps/Support Engineer (P3)
$132,538

Indeed.com

PayPal
San Jose, CA
Senior Software Engineer – DevOps Tooling
$123,500 to $212,850

June 23, 2025
Compliance in the Age of AI: Why Strong CI/CD Foundations Matter
In the age of AI-driven development, teams face a dual imperative: Harness the speed and creativity of code-generation tools while upholding the strictest standards of security, privacy and regulatory compliance. Nowhere is this more critical than in regulated environments — think banking or healthcare — where a single misstep can expose sensitive customer data or run afoul of GDPR, PSD2 and other consumer-protection mandates. How, then, can modern enterprises leverage AI to increase efficiency without increasing risk?

The answer lies in a rock-solid CI/CD foundation that weaves governance into every stage of the software lifecycle.

Balancing Speed Versus Control

CI/CD, continuous integration and continuous delivery, was designed to catch problems early in the development lifecycle and keep pace with rapidly changing market demands. It’s the foundation of DevOps; everything flows from your CI/CD pipeline, so getting it right is critical.

AI can dramatically shorten build cycles and accelerate code creation. Developers can now use tools like Cursor, Windsurf, Claude Code, Copilot and other AI assistants to generate code in seconds. But every burst of productivity brings potential risk. Just as human-written code needs to be rigorously tested against compliance standards, AI-generated code does too.

The efficiency gains AI promises can tempt teams to cut corners on essential checks and controls. Engineering and DevOps leaders must arm themselves with tools and processes that keep compliance front and center.

Rigorous Review and Testing for AI-Generated Code

Whether code comes from carbon-based lifeforms or large language models, more code tends to mean more bugs, more logic errors and potentially more security vulnerabilities. A robust CI/CD foundation enables automated audits, compliance checks and tests across every commit and build, ensuring issues are flagged and fixed before they hit production. For example:
- End-to-end testing of critical workflows on every build. This is especially vital for mobile apps, where a faulty update can have catastrophic consequences.
- Peer-review pipelines augmented by AI-driven alerts that highlight code quality issues, compliance gaps, or untested branches before merge.
- Progressive delivery patterns — canaries and feature flags — that limit blast radius and enable automatic rollback if an AI-assisted feature misbehaves in production.
These practices ensure that every line of AI-generated code meets the same security and quality bar as handcrafted work, while still letting teams move at AI-speed.

Leveraging AI as the Compliance Guardrail

Rather than viewing AI solely as a code generator, forward-thinking organizations deploy AI agents as compliance guardians within their CI/CD pipelines. A mature CI/CD system does more than move bits from repo to production — it enforces policy at scale. Key practices include:
- Integrating privacy-impact and vulnerability scans into every pull request to spot risky dependencies or misconfigurations early.
- Automating release approvals that require explicit sign-off on consumer-protection rules before pushing updates to real users.
- Maintaining an immutable audit trail of every build, test and deployment step — crucial evidence when regulators come knocking.
With these guardrails in place, compliance becomes a predictable, automated process rather than a last-minute bottleneck.

Controlling the Agency of AI Agents

AI agents can serve as powerful governance partners, continuously monitoring for compliance issues, detecting security vulnerabilities and ensuring that all code — whether human or AI-generated — meets regulatory requirements. But when AI agents make autonomous decisions, a new level of risk emerges: Agents can act without full contextual judgment and tracing of why an agent took a given action.

A strong CI/CD toolchain and proper configuration let organizations define the boundaries in which AI agents operate, including automated checks, verifications and controls.

Governance as a Competitive Advantage

In the AI era, governance isn’t just about avoiding problems — it’s about building trust and enabling faster, more confident innovation. Organizations with strong CI/CD foundations can leverage AI’s power while maintaining control over quality, security and compliance.

Practical governance strategies include:
- Ensure your CI/CD pipeline can handle the increase in volume of AI-generated code. Define clear boundaries and explicit policies for when and how AI tools are used.
- Speed is your edge, but control is your game-changer. With the right CI/CD and AI guardrails, you can make your release cadence and robust testing your competitive advantage.
- Foster a governance-aware, AI-curious culture. Train developers on AI and compliance requirements in parallel, demonstrate best practices and establish clear escalation paths.
By embedding security, privacy and compliance checks into your CI pipeline — and using AI agents for continuous auditing — you can unleash AI’s potential without compromising trust or compliance. This approach also reduces implementation complexity by leveraging your already approved, vetted and secure CI environment.

Build the DevOps Foundations Now to Scale in an AI-Driven Future

The era of AI has already brought massive productivity gains across the software development lifecycle, but implementing AI code generation tools or AI agents without the proper guardrails in place leaves organisations open to more risk and potential reputational damage. The future belongs to teams that see governance not as a constraint, but as a catalyst for responsible innovation.

A strong CI/CD foundation is key to ensuring you can reap the benefits of AI and create high-quality user experiences at breakneck speed.
June 20, 2025
AWS Extends MCP Support in Amazon Q Developer to Multiple IDEs

Amazon Web Services (AWS) has added support for the Model Context Protocol (MCP) with the Visual Studio Code and JetBrains plugins that are provided for Amazon Q Developer, a set of artificial intelligence (AI) agents that automate a range of software development tasks.

Originally developed by Anthropic, MCP support with these integrated development environments (IDEs) will make it simpler to invoke external tools that invoke some type of large language model (LLM).

Srini Iragavarapu, director of software development for Amazon Q Developer Coding Assistant, said this capability will make it easier to provide AI agents with additional context by providing access to additional data sources and application programming interfaces (APIs). Armed with those insights, it then becomes a lot simpler for developers to optimize the prompts they create to invoke Amazon Q Developer, he added.

That capability, in addition to creating more accurate code, will also make it simpler to integrate planning tools, create user interface components from designs and generate database documentation from actual schema without having to create additional custom integration code, noted Iragavarapu.

Previously, AWS only provided that capability via MCP support for the command line interface (CLI) option it makes available for Amazon Q Developer.

Over time, multiple classes of AI agents will emerge that provide different levels of reasoning capabilities that will be assigned tasks based on the level of complexity involved, said Iragavarapu. AWS also continues to evaluate the agent-to-agent (A2A) protocol put forward by Google to make it simpler for AI agents to communicate over a standard set of interfaces, noted Iragavarapu.

It’s not clear how widely AI coding tools have been adopted a Futurum Research survey noted, but found 41% of respondents expect generative AI tools and platforms will be used to generate, review and test code.

There is, of course, already no shortage of AI coding tools, so the pace at which code is being developed has already begun to accelerate. Exactly how much of that code is making it into production environments is unknown. However, the next major challenge will be incorporating AI agents into the software engineering workflows used to deploy applications. Many of the DevOps pipelines relied on today to deploy software were not designed to handle the volume of code being generated by AI tools. The expectation is that many of the brittle scripts that DevOps engineers rely on today to create pipelines will eventually be replaced by AI agents that can perform tasks at higher levels of scale.

In the meantime, each organization will need to determine to what degree they may want to standardize on a specific AI tool versus letting each developer select one based on their personal preference. The important thing is to remind developers to review the code created by AI coding tools that, on occasion, are still prone to hallucinations. After all, even if a machine wrote the code, it’s still a human developer who is ultimately responsible for the quality of the code being created.

June 19, 2025
Why AI-based Code Generation Falls Short
Artificial intelligence (AI) has been used in several industries to automate procedures, increase efficiency, reduce errors, data analysis and improve decision-making. This helps businesses increase efficiency, innovation, productivity and customer satisfaction. AI has also been used in software development. This article talks about AI. AI-generated code, AI-powered code generators, the benefits, downsides and limitations and why human expertise is still needed to build applications that are reliable, robust and maintainable.

The Role of AI in Software Development

AI has just jostled its way into almost everything we touch and software engineering is no exception. The incorporation of AI in software engineering has been transforming software development processes in more ways than one. You can use AI to automate tedious tasks, generate source code faster, create code documents and even write unit tests.

The usage of AI in the software development life cycle of any project will facilitate faster workflows, thereby enabling your software developers to focus on creative and complex tasks instead of spending time on mundane tasks.

Here’s how AI can help in software development at a glance:
- Project Planning
- Project management
- Faster development cycles
- Generate source code
- Create code documentation
- Testing and debugging
- Assist in code reviews
- Build UI prototypes
What is AI-Generated Code?

AI-generated or AI-powered code refers to the source code produced by AI-powered tools rather than manually written by software developers that typically use machine learning models — often trained on vast datasets — to produce source code based on given inputs.

It involves the usage of AI-based code generators to generate source code by leveraging the advances in large language models (LLMs) and natural language processing (NLP).

Typical examples of inputs provided to these tools manually can include an instruction to generate a program based on a given scenario. The produced code could be a single function, a whole program, or simply a few useful lines to expedite a tedious task.

AI-enabled tools have altered the development landscape, relieving software developers from writing tedious code. As a result, this helps these developers address intricate coding challenges while automating source code wherever needed.

There are several benefits of AI-based code generation, such as the following:
- It reduces development time by generating code quickly and relieving the developers of having to write code manually
- Streamline processes in the software development life cycle by automating monotonous, tedious or mundane tasks
- It can help you generate unit tests quickly and efficiently
- By enabling you to generate code faster, AI can help boost the overall productivity
Where Does Generated AI Code Fall Short?

While AI-generated code can help software development, it is not at all a replacement for code written by human expertise because of the reasons discussed in this section.

Technical Debt

Although many AI-powered tools can generate source code for you, they seldom consider the design and architecture of your application or how the architecture components are related to one another.

Most importantly, if you’re using AI-generated source code, you might have code redundancy and even technical debt, as these tools do not reuse or refactor existing code but build everything from the ground up.

Quality Concerns

While it is excellent at generating code quickly for you, it cannot produce code by considering maintainability, reusability, or scalability and performance as a human software developer can. Additionally, AI-generated code can often be insecure and contain bugs. As a result, before you use such code, you must perform code reviews, make changes to the generated code to clean it up and make it free of bugs and then test the code thoroughly.

Maintainability Issues

Although the source code generated by AI-powered tools might cater to the functionality you need, it can be overly complex and contain unnecessary abstractions, which might make debugging and maintenance a nightmare. Worse, such inefficient issues may increase the KLOC (an acronym for Kilo Lines of Code,) making maintenance even more difficult. In software engineering, KLOC is a metric often used to measure the number of lines of code in an application.

How Does AI-Based Code Generation Work?

AI-powered tools such as ChatGPT and GitHub Pilot leverage advanced machine learning models and are trained from source code and natural language text that is readily available in public data sources and repositories. Software developers can take advantage of AI-powered tools to generate source code in various ways, such as the following:
- Autocomplete: Code is typed in manually and AI-powered tools can autocomplete the code
- Natural Language Input: Developers enter the specific requirements by entering text, prompting the AI-enabled tool to generate code. Once this input is provided, the AI-powered tools can produce relevant code for you.
- Direct Interaction: Chat directly with AI-enabled chatbots such as GitHub Copilot Chat
You can also take advantage of AI-powered tools to translate source code from one programming language to another.

AI-Based Code Generation vs Low-Code vs No-Code

AI-based code generation tools and the low-code and no-code platforms have one thing in common: They all can help you build applications quickly. Low-code platforms help developers build software applications without having to write code for each feature of the application. It encompasses a collection of reusable components that can be used to build applications simply by dragging, dropping and arranging the components in the user interface.

As the name suggests, no-code platforms enable developers to build applications using drag-and-drop user interfaces without the need of having to write even a single line of code. AI-powered code generation tools use Generative AI models to generate source code based on the inputs provided to them. While low-code and no-code tools often target non-developers and business users, AI-based code generation tools are typically used by software developers.

Future of AI-Powered Software Development

Because of the surge in AI usage, many AI-powered tools are already available to help you write code fast. Many more tools will emerge to help developers write code and optimize development workflows and efficiency.

While LLM technologies continue to evolve, AI code generation will become more popular. However, code generated using AI-powered tools will have defects and constraints, thereby requiring human intervention to refine the generated code and make it error-free and usable.

However, while AI may become more integrated into the development workflows, it will never replace developers. Instead, these tools will assist developers in generating code quickly and reduce the time spent writing repetitive code, thereby enhancing the team’s throughput.

Striking the Balance is Key

While AI-generated code won’t be able to match human code quality, it might greatly increase efficiency. While these tools can produce code quickly, there are a few drawbacks to using these technologies. Use a combination of AI-generated and human-written code in your apps to reap the maximum benefits of these tools in your projects.

Before using AI-generated code, make sure it passes all necessary tests. While AI-generated code may get you started, it might be necessary to rework it, so it meets the required standards for coding, design and architecture. To get the most out of AI, try incorporating AI-powered code into your project while bearing these things in mind. In essence, striking the right balance is what you need to do.

Key Takeaways
- AI is not a substitute for human capabilities, intelligence; it can help software development by generating code quickly.
- AI-based code generators are great, but they have several limitations as well
- Soon, AI will play a significant role in software development
- AI-based tools can help translate source code from one programming language to another programming language
- You should blend AI-powered tools with manual effort and intelligence to build high quality applications faster
- Some of the widely used tools for code generation include GitHub CoPilot, ChatGPT, Amazon Q Developer and Google AI Code Generation Tools such as Gemini, Code Llama and TabNine.
June 19, 2025
The Top 5 AI Trends for Developers

We’ve entered a transformative era where AI is fundamentally changing how developers build applications.  There’s a huge opportunity for developers to infuse apps with solutions powered by Generative AI and large and small language models. Today’s models are getting more advanced, and the versatility of these models can accelerate developer productivity.

However, developers need to keep in mind that context and customizations are crucial for successful enterprise adoption. Without proper context, AI models may produce generic or irrelevant outputs, negatively impacting the effectiveness and integration of AI workflows. Customizations ensure that AI tools meet the specific needs of each project or organization, making AI solutions worthwhile and aligned with business goals. By tailoring AI tools to fit unique requirements, developers can maximize the benefits of AI and streamline processes.

Here are some trends in the AI space for developers to keep in mind as they adopt AI in their applications:

Agentic Workflows

AI coding assistance has evolved rapidly — AI pair programmers are now becoming peer programmers. Gone are the days when developers would chat with AI or get simple code completion suggestions. Powered by advancements in AI models and available tools, today’s AI assistants are excelling in agent mode and actually doing things as a developer would, instead of merely suggesting. Humans are always in control, but it is quite remarkable to see agentic AI make wide, sweeping coding changes such as adding and editing files, pulling down dependencies, running scripts, installing tools and more. The next decade of the developer landscape is poised to look quite different if AI agentic workflows continue their trajectory.

Model Context Protocol

One of the challenges with modern AI, however, is providing context to AI models — Model Context Protocol (MCP) can help. MCP is an open industry protocol that standardizes how applications provide context to AI LLMs. Developers can think of it as a common language for information exchange between AI models. Developed by Anthropic, MCP aims to provide a standardized way to connect AI models to different data sources, tools and non-public information. MCP provides an easy way for deeply contextual tasks to be exposed as tools for AI Agents—think APIs, data, documentation, actions and more, all with secure authentication/authorization. AI agents leveraging such tools from MCP Servers are much more proficient in accomplishing developer tasks, and they also inspire confidence as responsible companies can leverage their domain knowledge to build and maintain tools.

Context Matters

Whatever the developer’s use case, the use of AI tools can always benefit from better context. While it may not be ideal for every situation, developers can give coding assistants the context of the entire codebase. This way, AI tools can grok through all indexable files and responses will be powered by local context. More is usually better for AI—be it code comments, PR commit messages, terminal commands, or other usual developer tasks —the more examples AI can see, the better the responses to future prompts. AI models’ training is often time-boxed, and for newer or updated content, developers are now easily able to direct AI to look up the latest before acting on prompts.

Choices in AI

Developers have an increasing number of choices when leveraging AI. Some of the most popular coding assistants include GitHub Copilot, Cursor and Claude Code. The benefits of AI-powered coding assistance can be surfaced through a myriad of developer tools and IDEs, like VS Code, Visual Studio, Rider, Xcode, Eclipse and more. Also, not all AI models are created equal, as some are better for coding and others for reasoning or deep thinking. Developers can now choose what AI models work best given the task, with popular options including GPT-4o, Gemini 2.0 Flash, o1, Claude Sonnet 3.5/3.7 and more.

AI Customizations

The usage of AI tools does not need to be generic — in fact, it can be very personal or customizable to a team’s needs. Responses from most coding assistants can now be customized with instruction sets. These are often in the form of simple text files that can keep AI models grounded as per preferences. These techniques offer personalization options for prompt engineering. Tone of response, team coding standards, variable/function naming themes and more, can all be fed as inputs to AI. Traditional techniques of RAG are still great for grounding AI responses but might have scalability limits. Modern standards like MCP enable easier ways to customize AI responses and actions to conform to standard ways of accomplishing developer tasks.

The emergence of AI offers developers the ability to expand and improve their application of Generative AI. As models become more advanced, they can significantly increase productivity and lessen the workload for developers. However, it’s important to note that for successful enterprise adoption, AI needs to be tailored with the proper context and customizations. By tailoring AI tools to specific needs, business goals or projects, AI can be successfully embedded in enterprise organizations and help developers make the most out of AI tools.

June 19, 2025
Atlassian Adds CLI Option to AI Agent for Building Software

Atlassian has added a command line interface (CLI) option to provide application developers with a familiar construct for invoking Rovo Dev, its artificial intelligence (AI) agent for building software

Part of a portfolio of Rovo Software Agents that Atlassian now makes available in beta, Rovo Dev completes and debugs code, creates tests, surfaces insights and explanations of code bases, makes suggestions to improve code and generates documentation. It is also integrated with Jira project management software and Confluence collaboration tools provided by Atlassian.

Using a set of software engineering (SWE) benchmarks maintained by researchers at Princeton and Stanford, Rovo Dev achieved a 41.98% resolve rate across 2,294 tasks.

It can also be integrated via a Model Context Protocol (MCP) Server to access external data sources capable of providing more context that might be needed to complete a specific task.

Shuyin Zhao, vice president of product for Atlassian, said the goal is to provide a single agent capable of performing a wide range of tasks versus requiring developers to create workflows that require them to orchestrate multiple agents to build and deploy software. The more memory that can be allocated to an AI agent the more it is able to preserve context, she added.

Longer term, as the reasoning capabilities provided by large language models (LLMs) continue to expand, the scope of complex tasks that can be assigned to that AI agent will also increase, noted Zhao.

Eventually, many developers will find they will be spending more time reading and evaluating code rather than writing it themselves, she added.

It’s not clear how widely AI tools are being adopted by software developers and engineers, but a Futurum Group survey found 41% of respondents expect generative AI tools and platforms will be used to generate, review and test code. The one thing that is certain is more developers than ever are using these tools to write code, but how much of that code is making it into production environments is unknown. In some instances, an AI tool might enable a developer to write better code than they can on their own. In other instances, it might create vulnerabilities or recommend using software packages that simply don’t exist.

Additionally, even as more code is generated, the existing DevOps pipelines might not be robust enough to deploy software at higher levels of scale than what is already being achieved.

None of that means AI agents won’t be incorporated into DevOps workflows, but it does mean there is still a considerable amount of effort required to re-engineer those processes in a way that is optimized for AI agents rather than human application developers.

In the meantime, however, DevOps teams would be well-advised to start creating a list of tasks they are willing to delegate to AI agents, assuming there is some level of supervision. Otherwise, it’s all but inevitable that AI agents might generate the same issues that human developers create, albeit just at a different level of scale. The issue then becomes making sure the right governance policies are in place to prevent as many of those issues from arising in the first place.

June 18, 2025
AWS Extends Cloud Security Reach to Include DevSecOps Tools to Scan Code

Amazon Web Services (AWS) this week made Amazon Inspector, a code scanning tool for surfacing vulnerabilities that is designed to be natively integrated with GitHub and GitLab platforms, generally available.

Announced at the AWS re:Inforce 2025 conference, Amazon Inspector combines a static application security testing (SAST) tool for analyzing application source-code with a software composition analysis (SCA) tool for evaluating third-party dependencies and an ability to scan infrastructure as code (IaC) for valid definitions.

Findings from these scans are then surfaced both in the Amazon Inspector console and within the source code management platform as fast feedback for the developers.

Mitch Ashley, vice president and practice lead for software lifecycle engineering at The Futurum Group, said the expansion of the DevSecOps capabilities provided by AWS into code, dependencies, and IaC enable a critical ‘shift left’ for cloud security, fundamentally embedding vulnerability management earlier into the development lifecycle. That unified approach addresses a long-standing challenge for DevOps teams by accelerating feedback and fostering truly secure-by-design applications, he added.

Additionally, AWS also revealed it has made available under an open source license a software package, dubbed @verifiedpermissions/authorization-clients-js, that enables developers to implement authorization in Express.js web application APIs in minutes. That approach reduces the custom authorization code that developers would have previously needed to create on their own.

Finally, AWS demonstrated how it is internally using Amazon Q Developer, an artificial intelligence (AI) agent framework, to identify vulnerabilities in code as it is being developed.

George Argyros, applied science manager of AWS, told conference attendees Amazon Q Developer makes it possible to “squash bugs” early in the application development process in a way that ultimately serves to improve the quality of the code being created. The overall goal is review code at the time a pull request is made and then surface recommendations to mitigate any issue, with Amazon Q Developer also being used to create and test any patch required.

It’s not clear how widely the DevSecOps tool and platform being provided by AWS have been adopted, but it’s clear the cloud services provider is now moving well beyond securing infrastructure. It’s still the responsibility of organizations to secure the applications deployed on the cloud, but AWS is making the tools and services needed to achieve that goal more accessible.

Hopefully, there will even come a day soon when application development teams are routinely using AI tools to prevent vulnerabilities and misconfigurations from being created in the first place.

In the meantime, however, DevOps teams need to be sure to review the code being generated by AI tools that have been trained using examples of code that is of varying quality. In one instance, that code might be better than what some developers might write on their own. In other cases, segments of code with known vulnerabilities might have been copied multiple times over. In fact, about the only thing that is for certain is that there will soon be more code than ever to scan and review as developers continue to lean on AI tools to create code that they are becoming less inclined to write themselves.

June 18, 2025
CloudBees Adds MCP Server to Unify Platform for Integrating DevOps Workflows

CloudBees today began providing early access Model Context Protocol Server to its Unify platform for centrally managing DevOps workflows across multiple types of continuous integration/continuous delivery (CI/CD) platforms.

Originally developed by Anthropic, MCP has emerged as a de facto standard for integrating artificial intelligence agents with each other and various data sources.

Shawn Ahmed, chief product officer for CloudBees, said MCP will enable CloudBees to extend the reach of its Unify platform to AI agents that are becoming incorporated into DevOps workflows. The CloudBees MCP Server provides a lightweight, standardized interface between large language models (LLMs), such as OpenAI’s GPT and Anthropic’s Claude, and enterprise DevOps tools and processes, he added.

The overall goal is to make it simpler to orchestrate and automate multi-step tasks spanning multiple AI agents by making pipeline, test, security data and associated metadata, including metrics, available to AI agents via the CloudBees Unify platform, noted Ahmed.

Launched last month, CloudBees Unify is a software-as-a-service (SaaS) platform for centralizing the management of multiple DevOps environments, including GitHub, GitLab and the open source Jenkins continuous integration/continuous delivery (CI/CD) platforms. It enables DevOps and platform engineering teams to centrally manage application development environments more easily via a control plane for CI/CD platforms through which DevOps teams can govern and manage multiple platforms.

In effect, CloudBees Unify provides an operating layer on top of any existing toolchain that makes it possible to both surface analytics in real time, run tests and apply policies that require the running code scans and implement compliance policies. That capability can now also be extended to AI agents to ensure governance policies are followed as tasks are automated, noted Ahmed.

It’s not clear how widely AI agents are being deployed across DevOps workflows, but a Futurum Group survey found 41% of respondents expect generative AI tools and platforms will be used to generate, review and test code. The challenge now is determining to what level tasks can be assigned to AI agents in a way that will be reliably implemented. The issue isn’t so much whether AI agents will be used as much as it is to what degree. Additionally, DevOps teams will then need to determine how potentially hundreds of AI agents might be employed alongside the engineers, who, in addition to continuing to perform some tasks themselves, may need to manage a small army of AI agents.

Ultimately, each DevOps team will need to determine their level of comfort with AI, but the one certain thing is that there is no shortage of manual DevOps tasks to be automated. It’s not likely AI agents will replace the need for software engineers but the nature of the role will undoubtedly change, especially as AI agents increasingly eliminate the need to write custom scripts.

In the meantime, however, DevOps teams would be well-advised to revisit how their existing pipelines are constructed. After all, the more brittle those pipelines are, the more likely it becomes that AI agents will stress them to the point of breaking.

June 18, 2025
Merging Business Logic and DevOps

I remember recently sitting with one of our application owners, trying to figure out why automation initiatives felt perennially stuck. Everyone on the infrastructure side had scripts that handled tedious tasks, and our development teams had pipelines that delivered code faster than ever — yet executives remained stuck on why automation wasn’t creating the kind of business impact they had expected. The answer was simple: We had never articulated our work in terms of the goals they focus on. In other words, I saw that bridging the gap between DevOps and business logic was the way past the buy-in ceiling.

Where DevOps Hits the Business Wall

DevOps started as a way to merge the needs of developers and infrastructure engineers so code could flow from commit to production in a seamless pipeline. That approach dramatically cut the time it took us to deploy new features, and it reduced environment inconsistencies that usually caused failure. Those early gains were dramatic — fewer manual handoffs, more frequent releases and far less friction between dev and ops.

Yet I kept noticing that DevOps alone didn’t help me answer bigger questions like, “How does this release improve our margins?” or “Where do we see profitable opportunities for automation?” Developers focused on bug fixes and features, and infrastructure folks prioritized stability and performance. Neither side was accountable for tying these deployments to corporate growth or profit goals. The impact is there. A study examining DevOps implementations found that organizations that embedded business-facing roles into DevOps practices saw measurable financial benefits, including revenue increases and faster time-to-market, reinforcing the importance of aligning development efforts with corporate objectives.

That misalignment is also what prevents organizations from moving beyond departmental automation into business-driven outcomes. It’s one thing to automate code deployments; it’s quite another to automate an entire client onboarding process with cost controls, compliance reviews and marketing triggers baked right in.

The Business Logic Layer

Rather than hoping that new features alone — fancier CI/CD tools, or better infrastructure monitoring — will deliver a business advantage, it means threading revenue goals, product metrics, compliance thresholds and even marketing feedback loops into the same pipeline that developers use. When the pipeline can incorporate these upstream needs, a new product launch automatically triggers finance approvals, governance checks and environment provisioning without manual sign-off. That’s when my scripts stop looking like pure tech solutions and start looking like measurable ROI. This alignment is what separates DevOps as an efficiency tool from DevOps as a revenue enabler.

The Critical Role of Application Owners and Product Managers

An application owner is usually close enough to the code to understand how it’s built and close enough to the business to know why it’s built. The same is true of product managers who have to balance feature sets with market demand. They are the natural bridge between a pure DevOps mindset and the more complex perspective an executive might have.

I’ve seen these roles act as the translation layer. They take business requirements and shape them into tasks that developers can automate. They also bubble up constraints — like compliance or security standards — that infrastructure teams enforce. When these roles gain a say in how the pipeline itself operates, we can stop limiting our automation to low-level tasks and start automating real business workflows. Companies that have taken this approach have reduced financial processing errors by 80%, demonstrating the power of automation when applied beyond deployment workflows.

Automation as a Business Force Multiplier

Once product and application owners map out key business outcomes, we can embed them in DevOps pipelines. Many of us start with a string of scripts that manage simple chores like environment provisioning. That’s Stage 1 or 2 in the typical automation maturity model. By the time we’re hitting Stage 4 or 5, an entire product release or a client onboarding becomes a single automated workflow. It touches CRM entries, compliance gating, network segmentation, and deployment to production without anyone having to do it manually.

I’ve watched this reduce wait times for new product deployments from weeks to hours, save operating costs by ensuring we’re not over-provisioning resources, and improve a sales team’s close rates because they can promise faster delivery. Without strong ties to business logic, those same DevOps practices remain restricted to IT cost savings. With business integration, they become revenue and margin drivers. BMW’s process automation efforts in their supply chain demonstrate this impact at scale — shorter production cycles and substantial cost savings directly resulted from enterprise-wide automation.

Empowering Non-Technical Teams

It’s tempting to assume that only developers or infrastructure engineers benefit from pipeline insights. When business logic provides a bridge to marketing, HR, finance, or support teams, they suddenly see ways to automate their own workflows — like a marketing campaign that syncs with staging releases to gauge new features for promotional materials, or an HR system that automatically spins up application access for new hires.

Some of the hardest transitions happen here because non-technical teams may not see their goals as targets for automation. I show them that well-designed DevOps toolchains can be configured to automate tasks in plain language. If finance has to do an audit or a compliance check, we can embed it as a pipeline gate that no new product feature can bypass. That standard keeps us secure, and it keeps finance engaged in real-time. Organizations that introduce automation broadly across teams not only see efficiency gains but also a significant boost in employee satisfaction, with 65% of knowledge workers crediting automation for reducing stress and improving workflows. And in this way, it’s only by adopting the enterprise-wide language of business that DevOps can deliver its full value.

June 17, 2025