devopsy.kinsta.cloud

Tag: coding assistants

Splunk Open Sources Token Meter Tool for Application Developers

The Splunk arm of Cisco has made available an open-source tool that reads local Claude Code and Codex logs on a local machine to surface the live cost and activity of an artificial intelligence (AI) agent session.

Dubbed Token Meter, the tool reads the trace files an AI agent writes to disk and prices them against public model rates to help application developers become more aware of the cost of long-running sessions or tasks that could be performed using a less expensive AI model alternative.

Designed to run on Linux, macOS and Linux machines running Claude, Codex, Cursor, OpenCode, Kiro or Pi coding agents. Specifically, the tool surfaces output speed in tokens per second, the time the run spends waiting on the model, the split between fresh input and generated output and how much an AI agent handed back after a tool call.

Developers can also identify current, completed, or historical sessions using runtime, model, state and time filters in addition to tracing executions, events, tool activity, context growth, retries, failures, coverage, and warnings about session statistics. They can also compare tokens, estimated cost, timing, context, executions, and tool activity across agents, models, days, sessions, and tools.

A dashboard also keeps a timeline of raw events, a tools tab for stats on usage, an insights tab for derived signals, and an alerts tab for budget state. Token Meter will send a notification when a run crosses a threshold or the cost spikes. A read-only Model Context Protocol (MCP) server then makes it possible to pull that data directly into an AI coding agent.

In general, application development teams are trying to strike a balance between tasks that should be assigned to an AI model versus relying on some type of context engine to help reduce the number of tokens that an AI agent is likely to consume.

Hao Yang, vice president and head of AI for Splunk, said that as AI continues to advance, DevOps teams should be able to strike a better balance between consuming tokens and relying on platforms from, for example, Splunk to minimize consumption of tokens. Eventually, how AI agents access and process data will become much more federated as providers of AI model services look for ways to help organizations keep costs under control, he added.

While the cost of an individual token continues to decline, the volume of tokens being consumed has been exponentially increasing. As such, many organizations are now spending significantly more on AI than they initially intended. In fact, a recent Futurum Group survey finds that just under half of organizations are over their AI budgets.

In the meantime, DevOps teams will be tasked with reducing AI costs as application developers rely more on AI coding tools. The challenge, as always, is not solely reducing costs so much as it is ensuring the funds allocated to AI are actually being spent in the way that provides the most business value to the organization.

September 18, 2026
AI-Fueled Development Pushes Open-Source Risk to Extremes: Report

Artificial intelligence has shortened the timeline for software development from months to days. But according to new research, that acceleration is creating significant risks for security and compliance issues.

Black Duck’s 2026 Open Source Security and Risk Analysis (OSSRA), based on audits of 947 commercial codebases spanning 17 industries, shows that vulnerabilities inside enterprise applications has surged over the past year. The average number of open-source vulnerabilities embedded in an application rose a remarkable 107%, reaching 581 per codebase.

Open-source components now appear in 98% of audited applications, effectively making third-party code a foundational layer of modern software. Over the past year, the number of open-source components per application climbed 30%, while file counts expanded 74%. The increase reflects not only developer productivity gains but also a widening level of dependency.

Many of the vulnerabilities counted are inherited indirectly through nested dependencies, libraries within libraries, creating sprawling chains of exposure that are hard to unwind. Critical flaws were identified in 44% of applications reviewed, and high-severity issues appeared in 78%.

Meanwhile, software supply chain attacks have become more of a threat. Sixty-five percent of surveyed organizations reported experiencing such an attack within the past year, revealing that hackers are actively targeting these layered ecosystems.

AI Coding Assistants

The normalization of AI coding assistants is driving these problems. More than half of organizations formally allow developers to use AI-powered tools, and even companies that officially block the tools acknowledge informal adoption. These systems are optimized to produce functional code rapidly, often recommending widely used libraries without evaluating whether those dependencies increase the attack surface.

Traditional application security models assumed code would be written and reviewed at human pace. Yet automated code generation introduces dependencies far faster than security teams can catalog and remediate them. The imbalance is creating a widening gap between coding speed and human oversight capacity.

Maintenance practices add another layer of exposure. The OSSRA findings show that 93% of audited codebases included components that had not seen active development in at least two years. Ninety-two percent relied on software that was four or more years old, and a mere 7% of components were fully up to date.

When dormant projects later reveal security flaws, companies face tough choices: replace the component, assume maintenance internally, or accept the compliance risk.

Potential Legal Issues

Legal uncertainty is a growing issue. Sixty-eight percent of reviewed codebases contained conflicting open-source licenses, the highest rate recorded in the report’s history. Again, the integration of AI-generated code is contributing to the problem. Models trained on public repositories may use fragments governed by restrictive licenses without carrying forward the associated obligations. If this is built into commercial software without scrutiny, those fragments can create intellectual property problems.

Despite the rising exposure, comprehensive review practices remain spotty. A minority of organizations conduct full-spectrum evaluations of AI-generated contributions for security, quality and licensing compliance. Code introduced through copy-and-paste workflows or automated suggestions may not be captured by traditional manifest-based scanning tools, limiting visibility.

The bottom line here, it seems, is that even as code is written at ever faster rates, transparency into what is running in production might prove more important than the speed at which it was written.

February 27, 2026
The Rise of Coding Assistants: Supercharging Developer Productivity

The rapid advancements in large language model (LLM) coding assistants have sparked debates about the future of coding, with some even predicting doomsday for coders. But in Heroku, we see a different trend — LLMs are democratizing coding, so much so that we are beginning to see a wave of novice software developers jumping into the business.

This influx of programmers presents some unique challenges for AI assistants. Experienced developers, for example, are better equipped to notice when an assistant is leading them down the wrong coding path whereas junior developers might fail to notice something is amiss.

Additionally, an LLM’s code quality can vary greatly depending on language choice and application area. Utilizing the assistant to write a Python or Java backend is usually not a problem; however, asking it to write Zig or a newer language like Mojo can end in disappointment. For example, when asked how to install Python packages, an assistant will direct a user to use pip or conda as those are the most common tools in their training data. Meanwhile, developers are off late preferring Poetry for dependency and management packaging in Python; AI tools do not ideally use or consider that unless a developer asks for it specifically.

Outdated information can also be a problem, especially when languages and frameworks try to phase out old features or when libraries that were once in use contain security vulnerabilities that haven’t been fixed yet.

Harnessing Data to Supercharge LLMs for Developers

So, how do we help assistants (and by extension, developers) avoid such snags? Firstly, it is critical to have current data informing LLMs. While larger organizations can use their existing codebases and operational data to partially address this issue, complete access to comprehensive, up-to-date datasets is unavailable. In fact, 62% of global workers say training AI on out-of-date data breaks their trust in the tool. Similarly, companies lack enough relevant data when introducing new languages or trying to change the status quo.

The necessary data curation can be addressed in a collaborative community-focused manner following patterns established by open-source projects. This does not mean we must agree on a single set of best practices. On the contrary, it makes sense for existing language, tooling and framework communities to each produce a dataset or Framework Knowledge Base (FKB) that is curated specifically for their area of interest.

The optimal method for augmenting existing models with these FKBs is not clear. But that should not prevent anyone from producing them. Whether it is wholly pushed into the context window, accessed via retrieval augmented generation (RAG), or used for fine-tuning, having timely, accurate and relevant data that remains consistent is the best first step.

Framework Knowledge Bases for LLMs

How does a user interact with these FKBs? Imagine a menu for users to select from when they activate their coding assistant. The user would choose one or more FKBs tailored to a particular goal. Each FKB would include a getting-started template for the assistant to work from. In addition to the template, the FKB would include code samples, best-practice guides and recommended libraries.

To maximize success, the datasets would be created and curated by language and framework experts. However, every journey starts with a single step, or in this case, a person with the capacity and willingness to forge ahead and make the first FKB. There are a few questions this pioneer would need to answer:

1. What license should the FKB use? Ideally, these datasets would be available to everyone. To ensure the broadest usage, one must pick something extremely permissive, such as Unlicense or CC0.

2. Where must the FKB be stored? Ideally, this is a place where people can collaborate on datasets and have an easy method to modify the dataset if they disagree on some choices. For example, a GitHub repository is a good fit because the template can be used directly and allows for stars, pull requests and forks. A Huggingface dataset could also work. Another idea is to include an ai-hints.json file directly in an existing repository.

3. What test data should be included for LLMs? In future, one of the challenges would be evaluating an LLM’s performance using a dataset. These evaluations would require test data as well as training data. To address this, the FKB must contain domain-specific examples that can be used as a test set to evaluate the performance of LLMs.

Coding Assistants Become Extraordinary Tools

Fostering a collaborative, community-driven approach to curating and sharing knowledge can help ensure that coding assistants become extraordinary tools that empower developers of all skill levels. This journey begins with the collective effort of the tech community to create and refine datasets that keep pace with the ever-changing landscape of programming languages and tools. Together we can build a future where coding assistants simplify coding and inspire innovation across the global developer ecosystem.

June 19, 2024
StarCoder2 LLMs Designed Specifically to Generate Code Arrive

ServiceNow, Hugging Face and NVIDIA have once again combined their efforts to advance a generative artificial intelligence (AI) platform that has been specifically trained to generate higher quality code than rival approaches based on general-purpose large language models (LLMs) such as ChatGPT.

StarCoder2 is a family of LLMs created by the BigCode community led by ServiceNow. Three iterations are starting now with a 3 billion‑parameter model trained by ServiceNow; a 7 billion‑parameter model was trained by Hugging Face, while NVIDIA built a 15 billion‑parameter model.

The 3 billion‑parameter model is capable of matching the performance of the original StarCoder 15 billion‑parameter model.

Nicolas Chapados, vice president of research for ServiceNow, said as AI research continues to advance, each successive wave of LLMs becomes more efficient. Each organization, depending on the use case and total cost, can then opt to deploy StarCoder LLMs either on a local machine or in the cloud. The more parameters an LLM has, the more infrastructure resources are needed to run any inference engine based on it.

The StarCoder2 LLMs were trained using 619 programming languages and can be extended to, for example, provide summarizations of code. The foundation of StarCoder2 is a new code dataset called The Stack v2 that is more than seven times larger than version 1 of the dataset. In addition, additional training has enabled the model to understand low‑resource programming languages such as COBOL, mathematics and program source code discussions. Organizations can also fine‑tune models with industry or organization‑specific data using open source tools such as the NVIDIA NeMo platform or Hugging Face transform reinforcement learning (TRL) techniques. StarCoder2 was built using data under license from the digital commons of Software Heritage hosted by Inria.

The overall goal is to provide development teams with LLMs that, in addition to being less likely to hallucinate, also generates code with much fewer vulnerabilities because the code generated is based on exampled vetted by the BigCode community, said Chapados.

It’s not clear right now how much of the code finding its way into production environments is being generated by machines versus humans. However, as LLMs continue to advance, the percentage created by machines will undoubtedly increase. The challenge DevOps teams now face is determining how to apply AI to pipelines that will increase in number as codebases not only proliferate but also become inevitably larger.

In the meantime, DevOps teams would be well-advised to become familiar with what type of LLM is being used to train the generative AI platforms being used to create code. The more general purpose an LLM is, the more likely it is to generate suboptimal code that DevOps teams are only going to need to eventually replace, especially if that code is consuming expensive infrastructure resources inefficiently.

There is, of course, as far as generative AI is concerned, no going back at this point. The issue now is determining how to keep track of the provenance of all the code being generated to determine how best to fix it whenever needed.

March 4, 2024
Legit Security Adds Sensors to Detect Usage of Gen AI Tools to Write Code

Legit Security today announced it has added the ability to detect when developers use generative artificial intelligence (AI) tools to write code to its application security posture management (ASPM) platform.

The ASPM platform developed by Legit Security already has discovery capabilities for application secrets, for example, enabled by sensors that are now being extended to include generative AI tools.

Legit Security CTO Liav Caspi said the overall goal is to allow DevSecOps teams to identify who uses these tools to write which types of code. Each DevSecOps team can then decide how stringently to enforce policies to either ban or limit usage of those tools, he added.

There is no doubt that generative AI tools are increasing developer productivity, but the large language models (LLMs) that provide the ability to generate code were trained using examples of code of varying quality collected from across the web. Much of that code either contains known vulnerabilities or is simply inefficient, which can manifest itself in the output surfaced by a generative AI platform.

The Legit Security ASPM platform, in addition to identifying generative AI tools being used in real-time, can also be employed to scan the LLM itself to identify security risks such as prompt injection and insecure output handling. Unfortunately, most cybersecurity teams are unaware of the extent to which application code generated by a machine might be insecure, so it currently falls to leaders of DevSecOps teams to determine what is an acceptable use of these tools. It may be perfectly fine to rely on a generative AI tool to create a script that will be used for an internal-facing application. However, using the same tool to write business logic that will be exposed to the internet may not be especially prudent.

It’s not clear how much of the code finding its way into software builds is being generated by a machine versus a human. In the longer term, the goal is to be able to identify that code by, for example, detecting substantial changes in the way code is normally written by a human developer, said Caspi.

Of course, while an ASPM may detect usage of generative AI tools that are connected to a corporate environment, there are still plenty of opportunities for developers to use these tools offline to create code that can later be added to a build using a code check-in tool. After all, many developers have used various shadow IT tools to write code for decades. Regardless of who or what wrote that code, however, it should still be reviewed.

In the meantime, the overall size of the codebase that DevSecOps teams will need to manage and secure will only exponentially increase as developers become more productive. Hopefully, more AI capabilities will soon be embedded into DevOps platforms to further automate the management of software builds at a time when many DevOps teams were already finding themselves overwhelmed even prior to the rise of generative AI.

February 13, 2024
10 Key Features of AI Code Assistants

One of the most potent tools that have emerged to streamline the coding process is code assistants. Code assistants are software tools designed to assist programmers by providing suggestions and automated features that help in writing code more efficiently and accurately. They act as virtual aides, making the coding process faster, more intuitive and less prone to errors.

Code assistants can be categorized into two types: Rule-based and AI-based. Rule-based assistants follow predefined rules and perform according to set guidelines. They are mainly used for syntax highlighting, code formatting and basic error detection. AI-based code assistants can learn from past coding patterns, predict what a programmer is trying to achieve and suggest appropriate code snippets. They are capable of understanding the context of the code and providing accurate suggestions, as well as generating entire blocks of code based on natural language instructions. Read this blog post for examples of popular AI coding assistants.

Whether you are an experienced software developer handling complex projects or a beginner, coding assistants can automate the tedious aspects of coding, allowing you to focus more on problem-solving and innovation.

The Growing Importance of AI in Software Development

As software development becomes more complex and time-sensitive, the role of AI in this field has grown significantly. AI-driven code assistants represent a major shift in how software is developed. They bridge the gap between human expertise and the efficiency of automated processes.

AI in software development not only speeds up the coding process but also enhances the quality of the code. These tools can analyze vast amounts of code, learn from it and apply that learning to assist developers in real-time. They can adapt to different coding styles and requirements, making them versatile tools for a wide range of programming tasks. Furthermore, as software projects increase in size and complexity, AI code assistants become crucial in managing and navigating these complexities. They offer intelligent insights, detect potential issues before they become problematic, and assist in keeping large codebases clean and manageable.

In addition to increasing efficiency, AI code assistants are instrumental in reducing the barrier to entry in software development. They make coding more accessible to people with varying levels of expertise, including those who are new to programming. This accessibility is essential in an era where the demand for software development skills is continuously rising. By providing real-time assistance and learning resources, AI code assistants are not just tools for current developers but also learning aids for future generations of programmers.

10 Key Features to Expect from Code Assistants in 2024

With the rapid advances in large language models (LLMs), the following features are becoming standard in coding assistants as we enter 2024.

Advanced Contextual Understanding

Modern code assistants are evolving to understand the context of code more intricately. Unlike simple autocomplete tools, these AI systems can analyze the broader scope of a project, recognizing patterns and offering suggestions that align with the overall architecture and design patterns. This advanced understanding not only streamlines coding but also aids in maintaining consistency throughout the codebase.

Real-Time Code Optimization Suggestions

AI tools can proactively recommend changes to improve performance and efficiency. For instance, a code assistant might suggest a more efficient algorithm or highlight redundant code blocks that can be simplified. This feature not only enhances code quality but also serves as a learning tool for developers, exposing them to best practices and alternative approaches.

Enhanced Debugging Assistance

Debugging is often a time-consuming aspect of development. In 2024, expect code assistants to revolutionize this process by offering enhanced debugging assistance. Through deep analysis, these tools automatically detect errors and anomalies, suggesting potential fixes. They can pinpoint the exact location of a bug and provide context, significantly reducing the time developers spend in the debugging phase.

Automated Refactoring

Refactoring is crucial for maintaining clean code, and AI-driven assistants now offer sophisticated automated refactoring capabilities. They intelligently suggest changes that improve code readability and maintainability, such as restructuring code or renaming variables for clarity. These suggestions will be particularly beneficial for managing and updating legacy code, ensuring it adheres to modern coding standards.

Code Documentation Generation and Update

Keeping documentation updated is a challenge. Code assistants can now automate this task by generating and updating documentation in real-time. As code changes, the documentation will reflect these updates, ensuring that it always stays in sync with the codebase. This feature will be invaluable in large teams where keeping track of changes can be daunting.

Predictive Coding Assistance

Moving beyond reactive suggestions, code assistants will offer predictive assistance. By analyzing coding patterns and project structures, these tools will predict a developer’s next steps and offer relevant suggestions even before they are explicitly requested. This proactive approach will speed up the development process, reducing the cognitive load on developers.

Understanding and Responding to Developer Queries in Natural Language

Developers can pose queries or express coding requirements in plain English, and the assistant will interpret and execute these requests. Chat-based interfaces offered by leading AI coding assistants take this one step further. This advancement will make coding more intuitive and accessible, especially for beginners or non-expert users.

Real-Time Suggestions and Conflict Resolution in Team Projects

Collaboration in coding projects can lead to conflicts and inconsistencies. Code assistants now offer real-time suggestions and automated conflict resolution for team projects. These tools will identify potential conflicts in merge requests and suggest optimal resolutions, enhancing team collaboration and maintaining code integrity.

Personalized Coding Assistance Based on Past Interactions

Personalization is becoming a significant feature of code assistants. By learning from past interactions with a developer, these tools will tailor their suggestions and support to align with individual coding styles and preferences. This adaptive learning approach ensures that the assistance provided is most relevant and efficient for each developer.

Enhancing Accessibility of Coding for Non-Expert Users

One of the most impactful features of code assistants is their role in democratizing coding. By simplifying complex coding concepts and automating mundane tasks, these tools will make software development more accessible to non-experts. Beginners and those learning new programming languages will find these assistants particularly useful, as they provide guidance and learning aids.

Conclusion

Code assistants powered by AI are becoming an integral part of the software development process. They not only make coding faster and more efficient but also reduce the chances of errors, making the resultant software more reliable. The role of code assistants is only expected to grow, bringing in more advanced and intuitive features. Whether you are a seasoned programmer or a newbie, embracing code assistants can be a game-changer for your coding journey.

February 6, 2024
Does Using AI Assistants Lead to Lower Code Quality?

The emergence of generative AI has permanently altered how code gets written — and due to the massive productivity boost, there’s no going back. According to GitHub, 92% of developers said they use AI tools, and developers complete tasks 55% quicker using Copilot, the popular LLM-based code generator.

Yet, new research has potentially upset the idea that AI assistants like Copilot are positively advancing software development without consequences. The report, conducted by GitClear, analyzed over 150 million lines of code over the last four years and found an upsetting uptick in code churn and a decrease in code reuse since the dawn of LLM-driven software development.

So, this begs the question: Does using AI assistants actually lead to lower code quality? Well, the answer is complicated. “I wouldn’t say that the report proves that AI assistants are reducing code quality since our data is correlational,” said Bill Harding, programmer and CEO at Amplenote & GitClear, the organization behind the aforementioned research. “But I would say that there is a confluence of indicators that show code quality decline at scale, starting around 2022 and accelerating in 2023.”

AI-Generated Code Increases Overall Volume

One potential contributor to lower code quality is the sheer amount of code produced. Since LLMs automate code generation, production is accelerated across the board. Without guardrails, generative AI will likely contribute to more technical debt.

“AI-enabled code development is going to have a major effect on coding, exponentially increasing the volume and velocity of code delivery, much of which we anticipate will be of lower quality and more bloated,” said Mehran Farimani, CEO, RapidFort.

In addition to quality concerns, there are also governance and security concerns to consider from the use of AI and surges of new code production. Some anticipate this will overwhelm security teams, which have already been struggling to keep pace. “Increased developer velocity is going to put security teams under even more pressure,” said Farimani. “The volume of scans will increase, the range of vulnerabilities that need to be addressed will increase and the patches that need to be applied will increase.”

Blindly Relying on AI Outputs

According to GitHub, developers accept code completions from Copilot 30% of the time. This percentage is likely to keep increasing as the LLM is trained on internal style and comfort with the tool increases. However, there is still the risk of developers blindly relying upon generative AI outputs without giving them the proper oversight, which could also affect code quality.

“I think there is a risk for lower quality code if a developer blindly relies on what an AI assistant generates,” said Rob Whiteley, CEO at Coder. “Generative AI tools have flaws, and if outputs are not verified, they can insert code that compiles but does not behave as a developer may have intended. It can also insert errors or bugs if not checked.”

How to Retain Code Quality in the AI Age

“I would not say that results of [the GitClear] study are conclusive,” said Dr. Eirini Kalliamvakou, staff researcher at GitHub. She believes the results are misleading since there is no way to know if an AI or a human authored the code that was analyzed for the study. That said, she acknowledged that “if we are helping people code faster, we should ask the question about code quality.” So, how do we retain the quality of all code, regardless of whether it’s human- or machine-generated?

Use Copilot Thoughtfully

The first recommendation is to use AI assistants thoughtfully. If you’re exhausted at the end of a long day, it’s a lot easier just to “hit tab” and accept an AI-generated auto-complete. But this might not be the best move. “When used thoughtfully and with oversight from the developer, I do think AI can improve the quality of a developer’s code by making suggestions and preventing human errors,” said Whiteley.

Apply the Same Code Reviews to AI-Generated Code

Additionally, development teams should be applying the same degree of rigor to AI-generated code, taking it through the same design review processes and security reviews as you would for any new application. “Just because you’re writing with Copilot doesn’t mean you should give up on code reviews, your linters, looking for security vulnerabilities and all that,” said Kalliamvakou.

Avoid Redundancy When Possible

Leaner code means efficiency boosts and cost-savings. “Much of code is redundant and AI can streamline that redundancy and offer interesting insights, but not without developers ensuring the suggestions the AI tool makes align with the code they are intending to write,” said Whiteley. “Similar to Gmail’s autocomplete sentence feature, AI can complete lines of code with accuracy, but only as long as it accurately guesses where you’re going with your sentence.”

Keep Tabs on the Impact on Quality

Multiple sources cited that around 30% of code is now AI-authored. Harding calls for more efforts to analyze the impact of AI generation on code quality. “It would benefit the greater good to get a clear and data-backed assessment of how quality fluctuates when developers hit ‘tab’ to accept an AI suggestion,” he said. This is a new field of study, and will require new metrics to fully monitor and appreciate the impact AI has on code quality.

Determine How To Measure Code Quality

Similar to the dearth of consensus on what exactly constitutes developer productivity, defining and measuring code quality is just as challenging. Therefore, Kalliamvakou recommends first defining what code quality means to your organization and what the metrics are. For instance, this could be the “number of defects.” Then, the next step would be to set up methods to alert developers about potential quality issues, she said.

The Bottom Line: AI Enhances Productivity…

AI assistants are changing the way code gets made, and much of this is for the better.

Most notably, AI can have a significant impact on enhancing productivity for up-and-coming or inexperienced developers. “If an enterprise makes technology like generative AI broadly available, then it can supplement the work and boost the productivity of the base of the talent pyramid,” said Whiteley. “Put simply, that investment massively impacts the broader organization, not just the top 1% of developers.” Even if such tools make a developer 20% more productive, they can have a truly transformative impact.

While the GitClear study doesn’t prove the culpability of AI assistants, it raises some interesting questions worth exploring, said Harding. Notably, is code becoming more repetitive? If so, that could have some negative outcomes for overall efficiency. “Code generated during 2023 more closely resembles an itinerant contributor, prone to violate the DRY-ness of the repos visited,” the GitClear report said.

… So, Assess Code Quality

“If leveraged correctly, generative AI will not lower the quality of code,” said Trisha Gee, lead developer advocate at Gradle, Inc. “However, it’s important that developers using this technology are critically evaluating AI-generated code rather than taking what AI suggests at face value. Code from generative AI may not always be ‘correct,’ be the best solution to a problem or match the code style of the codebase.”

My takeaway is that, yes, you can retain code quality while using AI assistants. However, this assessment comes with some strings attached. It will require an ongoing effort to sanitize the outputs of AI and instill the same checks we typically apply to manually-generated code.

Image source: https://vecteezy_futuristic-technology-concept-mixed-media-innovations-data_7019122_167-3.jpg

February 6, 2024