Grit automatically fixes technical debt by combining static analysis and machine learning to generate pull requests that clean up code and migrate to the latest frameworks.
How Grit.io can help you:Â
Why choose Grit.io: Key featuresÂ
Who should choose Grit.io:
Categories
Correct Your Vibe Coding Errors with Shotgun Code
Have you ever stared at a tangled mess of code, wondering how it spiraled so far out of control? For developers, a broken or poorly documented codebase isn't just an inconvenience -- it's a productivity nightmare. Hours are lost deciphering cryptic logic, patching bugs, and untangling spaghetti code, only to feel like you're barely making a dent. Enter Shotgun Code Cursor AI: a new tool that promises to transform even the most chaotic codebases with a single, intelligent prompt. By using the power of advanced large language models and seamless integrations, it offers a bold solution to one of software development's most persistent challenges. What if refactoring didn't have to feel like an uphill battle anymore? AI Labs explores how Shotgun Code is reshaping the way developers approach large-scale refactoring. You'll discover how it uses innovative AI to analyze and optimize code, even in projects riddled with inefficiencies or lacking proper documentation. From automating repetitive tasks to allowing customized improvements, this tool is designed to save time, reduce errors, and let you focus on solving higher-level problems. Whether you're wrestling with a legacy system or modernizing a sprawling application, Shotgun Code offers a glimpse into a future where refactoring is no longer a dreaded chore but an opportunity for innovation. Could this be the breakthrough your workflow has been waiting for? Shotgun Code is a sophisticated tool specifically designed to streamline large-scale codebase refactoring. It uses artificial intelligence to analyze, modify, and optimize code, even in projects that lack proper documentation or exhibit significant inefficiencies. By integrating seamlessly with complementary tools such as Cursor and Windsurf, Shotgun Code ensures that even the most complex refactoring tasks are manageable. Its ability to generate structured prompts and implement changes recursively makes it an invaluable resource for developers tackling challenging projects. This tool is particularly effective in addressing the unique needs of legacy systems, poorly maintained repositories, or large-scale applications. By automating repetitive tasks and providing actionable insights, Shotgun Code enables developers to focus on higher-level problem-solving and innovation. Setting up Shotgun Code is a straightforward process, requiring a few essential tools and steps. The tool relies on the Go programming language, Node.js, and Wails CLI for its core functionality. To get started, follow these steps: Once the installation is complete, you can begin optimizing your codebase. The setup process is designed to be user-friendly, making sure that developers can quickly integrate the tool into their workflow without unnecessary complications. Dive deeper into AI with other articles and guides we have written below. Shotgun Code provides an intuitive and efficient workflow, making it accessible for projects of all sizes and complexities. Here's how you can use it effectively: This structured workflow allows developers to maintain control over the refactoring process while benefiting from the automation and intelligence provided by Shotgun Code. Shotgun Code offers a range of features that make it a powerful tool for developers. Its standout capabilities include: These features make Shotgun Code a versatile and reliable solution for a wide range of development challenges, from optimizing performance to modernizing outdated systems. Shotgun Code has demonstrated its effectiveness across various real-world scenarios, delivering measurable benefits in diverse projects: These practical applications highlight the versatility of Shotgun Code in addressing a wide range of development needs, from improving user experience to enhancing backend performance. While Shotgun Code is a powerful and innovative tool, it does have some limitations that developers should be aware of: Future updates aim to address these limitations by integrating more features directly into the tool. This will simplify the refactoring process further and reduce dependency on external software, making Shotgun Code even more accessible and efficient. Shotgun Code provides a practical and efficient alternative to traditional refactoring methods, which often rely on extensive documentation and manual effort. By automating code analysis and modification, it accelerates development timelines, reduces the risk of human error, and enhances the overall quality of your projects. Whether you're working on a legacy system or a modern application, Shotgun Code equips you with the tools needed to streamline your workflow and achieve better results with less effort. Its adaptability, customization options, and iterative capabilities make it an essential resource for developers aiming to optimize their codebases efficiently.
Geeky Gadgets
Sat, 24 May, 10:11 AM UTC
GitHub rolls out new tool to fix code errors even before you see them
GitHub has announced the general availability of Copilot Autofix within its GitHub Advanced Security (GHAS) suite, designed to prevent new vulnerabilities from entering code before you even see them. The tool, announced by Chief Security Officer Mike Hanley in a blog post, will also tackle existing vulnerabilities in code, which was previously unmanageable without automation. Besides identifying code vulnerabilities, Copilot Autofix also promises to explain their significance and offer automated code suggestions to fix them. According to the company's research, the tool has already proven to be around three times more efficient than doing the process manually. Early adopters like Optum and Otto Group have also reported saving thousands of hours monthly on remediation tasks. Kevin Cooper, Principal Engineer at Optum, commented: "Since implementing Copilot Autofix, we've observed a 60% reduction in the time spent on security-related code reviews and a 25% increase in overall development productivity." In the announcement, Hanley was proud to highlight Copilot Autofix's ability to address the backlog of security debt - vulnerabilities that linger in software for extended periods, often going unnoticed. Tackling these types of vulnerabilities can significantly reduce the risk of costly security breaches. Hanley added: "Vulnerabilities can live forever, and the longer they've remained dormant, the harder and more expensive they are to fix." In addition to serving enterprise customers, GitHub will offer the tool to the open-source community for no cost from September 2024. Maintainers will be able to enhance the security of their own software, which aligns with the Microsoft-owned company's commitment to creating a safer software scene. Hanley concluded by stating that "AI agents can help relieve much of the burden" in a world of limited security talent, adding that Copilot Autofix will help ensure that "a vulnerability found means a vulnerability fixed."
TechRadar
Fri, 16 Aug, 12:04 PM UTC
How to Revive and Restructure Codebase with AI
A codebase can become messy and hard to manage over time. This happens because of quick fixes, outdated features, or just not enough time to clean things up. When code becomes difficult to read or change, it slows down progress and can even cause bugs. To keep a codebase healthy and easy to work with, you'll need to take care of it. Improving and organizing old code can feel like a big task, but there are tools and methods that can make it easier. This guide will show how to refresh your codebase step by step which will make it simpler to work with and less likely to cause issues. Code reviews are essential for catching issues early, improving readability, and ensuring long-term maintainability. Reviewing your own code or someone else's involves more than just scanning for errors - you'll also want to make sure each part is clear, efficient, and follows good practices. Here's a step-by-step approach to help you review code effectively, with practical strategies, tools, and what to look for during the process. There are a number of tools out there that can help streamline your code reviews, whether you're checking your own code or collaborating with others: Linters check for syntax errors, code smells, and style guide violations. They are especially useful for catching minor issues, like inconsistent formatting or unused variables. We will discuss ESLint more in an upcoming section. These tools analyze code for deeper issues like security vulnerabilities, code duplication, and complex functions that might need refactoring. Running tests can verify that code changes don't introduce new bugs. Use testing frameworks like Jest for JavaScript, PyTest for Python, or JUnit for Java to confirm your code behaves as expected. Let's say you encounter a long function with multiple responsibilities. The goal is to split it into smaller, focused functions. Here's how you can do that: Breaking down the process into smaller functions makes the code cleaner, more readable, and easier to test. Each function now has a single responsibility, which helps reduce bugs and makes future updates simpler. Technical debt refers to the accumulation of issues within a codebase that arise when development shortcuts are taken, often to meet tight deadlines or speed up releases. While these shortcuts may enable quicker progress initially, they lead to complications down the line. Technical debt requires proactive management. If you leave it unchecked, it can reduce productivity, create bugs, and slow down development. Think of technical debt like financial debt: taking on debt can be helpful in the short term, but failing to address it or pay it down will lead to greater challenges. Common causes of technical debt include: Technical debt manifests in different ways. Here are some common examples: 1. Code Duplication: Repeated code across multiple places within a project can lead to inconsistencies, as fixing an issue or updating a feature in one area may not carry over to others. Refactoring duplicate code into reusable functions or components is an effective way to reduce this debt. Example: In a web application, you might find similar code for user authentication scattered across different modules. Instead, centralizing this logic into a single authentication module ensures consistent updates. 2. Outdated Dependencies and Frameworks: Using old libraries or frameworks can slow down development and introduce security vulnerabilities. Over time, dependencies may lose support or become incompatible with new features, making them costly to maintain. Solution: Regularly update libraries and frameworks, and monitor for deprecations or vulnerabilities. This can be streamlined by using dependency managers, which help check for updates and security patches. 3. Complex, Long Functions with Multiple Responsibilities: Large, complex functions that handle multiple tasks are difficult to understand, test, and modify. Known as "God functions," these make debugging cumbersome and increase the risk of introducing new bugs. Solution: Follow the Single Responsibility Principle (SRP). This means that each function or method should accomplish one task. Breaking down large functions into smaller, focused units makes the code easier to read and test. Code that lacks proper error handling can lead to bugs and unexpected behavior, especially in larger systems. Without clear error messages, diagnosing and fixing issues can be challenging. Solution: Include comprehensive error handling and ensure that meaningful error messages are displayed. Log errors in a way that helps developers track and diagnose issues. 5. Hardcoded Values: Hardcoding values directly into code makes it difficult to adjust settings without modifying the source code. For example, using fixed URLs or credentials directly in the codebase can create security risks and maintenance headaches. Solution: Use configuration files or environment variables to store values that might change. This improves security and allows for easy updates. 6. Lack of Documentation and Testing: Documentation and testing are often neglected when time is short. But without proper documentation and test coverage, the code becomes challenging to understand and validate, slowing down development and increasing the risk of bugs. Solution: Implement test-driven development (TDD) or include time in the development cycle for creating documentation and writing tests. Aim for at least basic test coverage for critical paths and functions. Identifying technical debt is crucial if you want to address and improve it. Here are some strategies you can follow: Here's a practical example to demonstrate how refactoring can help address technical debt, specifically by removing code duplication. Let's say we have two functions that send different types of emails but use repeated code: Each function has a similar structure, so refactoring can make the code cleaner and reduce duplication. This example demonstrates how consolidation can reduce repetition and make the code more flexible. Proactively managing technical debt helps reduce it over time. Here are ways to avoid accumulating more debt: Code quality tools can help you find issues that might not be obvious. They can point out things like unused variables, code that's hard to read, or security problems. Popular tools include for , for , and for different programming languages. Here's how to set up a simple code check with ESLint: ESLint can automatically fix some issues for you. To do this, use the flag: This command will automatically correct issues like indentation, unused variables, and missing semicolons where possible. But it's important to review the changes to ensure they align with your intended functionality. Reviewing code, spotting technical debt, and using quality tools help keep the codebase healthy. If you follow these steps, your project will be easier to manage and less likely to break. Using AI tools to restructure code makes improving code quality much faster and easier. These tools help find issues, suggest changes, and can even automate some parts of the refactoring process. I'll share some AI tools that can help you with code analysis, refactoring, and dependency management, based on my own experience and what I've found useful. AI-powered tools are becoming more common, and they offer different ways to boost code quality and simplify refactoring. Here are some I've found helpful: GitHub Copilot is like a coding assistant that provides smart suggestions as you write code. It can complete code snippets, suggest new functions, and help rework existing code to make it more efficient. I've found it useful for writing repetitive code blocks or coming up with quick refactorings. For example, let's say you need to rewrite a function to be more efficient: GitHub Copilot might suggest optimizing the function like this: The updated version checks factors only up to the square root of , making it faster for large numbers. QodoGen provides automated suggestions for refactoring and can detect common code issues, like unused variables or large functions doing too many tasks. It also helps split complex code into smaller, more manageable pieces and can explain sections of the code base or the entire codebase which will facilitate the restructuring process. This tool is capable of doing this because, unlike other AI assistants and general purpose code generation tools, Qodo focuses on code integrity, while generating tests that help you understand how your code behaves. This can help you discover edge cases and suspicious behaviors, and make your code more robust. For example, if you have a function handling multiple tasks, QodoGen might suggest breaking it down: Separating the steps makes the code easier to maintain and test. ChatGPT can act as a helpful companion when working on code restructuring tasks. Arguably the most used coding assistant, it provides advice on refactoring strategies, explains how to implement changes, or offers example snippets. It's like having an expert to consult whenever you need guidance or ideas. For instance, if you're unsure how to optimize a function or restructure a class, ChatGPT can provide sample code or describe best practices. You can also ask it for help with understanding errors or fixing specific problems in your code. Just make sure you double-check the code it provides (same goes for all these AI assistants) as it can hallucinate and make mistakes. AI tools not only assist with writing code but also with analyzing it for quality improvements: SonarQube scans the code to detect bugs, vulnerabilities, and code smells. It generates reports with suggestions on what to fix, helping maintain a healthy codebase. This tool integrates with Visual Studio and offers automatic refactoring options. It highlights code that can be simplified or cleaned up and suggests ways to optimize the codebase. AI tools like DepCheck help find unused dependencies in JavaScript projects, keeping package files clean. Using AI tools like GitHub Copilot, QodoGen, and ChatGPT speeds up the process of code restructuring. They provide suggestions that save time and catch issues early, making the code easier to maintain. Combining these tools with automated analysis tools like SonarQube and ReSharper ensures all aspects of the codebase are covered, from quality checks to refactoring. These AI tools have other features that facilitate this process: for example, they all have a chat feature that lets you ask questions and get replies about your code and any best practices you should be following. Also, QodoGen allows you to add parts of or the whole codebase for context with the click of a button, along with other features for test generation and pull request reviews. When restructuring your codebase, having a variety of AI tools can make the process smoother and more efficient. This is AI usage at its best. Version control keeps track of code changes, making it easier to manage updates, collaborate with others, and fix issues. Following some best practices can help maintain a clean and organized codebase. Let's look at how to manage code changes, track updates, and ensure quality through code reviews. Git branching helps keep different versions of the code separate, allowing multiple developers to work without affecting the main codebase. Here are some common strategies: Feature branches allow developers to work on a new feature without changing the main codebase. Each feature gets its own branch, and once complete, it can be merged into the main branch. This strategy involves using multiple branches for different stages of development, such as feature, develop, and release. It separates development work and allows smoother integration and deployment. Example: Documenting code changes helps keep the team informed and makes it easier to understand what was done later. Here are some tips for tracking updates: Commit messages should explain what was changed and why. A clear message helps others know the purpose of each update. Example: Tags can be used to label important points in the project's history, such as release versions. This makes it easier to find stable versions of the code. A changelog lists the changes made in each version, helping developers and users see what was updated or fixed. Example format for a changelog: Code reviews help catch errors, share knowledge, and ensure code stays clean and maintainable. Here are some practices to follow for effective code reviews: Smaller changes are easier to review, making it more likely to spot mistakes. Large changes can be broken down into smaller parts. Pull requests create a space for discussion around changes. Team members can review the changes, suggest improvements, and approve the updates. Code reviews should aim to improve the code without discouraging the developer. Suggest better ways to solve problems and explain the reasoning. Example comments during a code review: Using these practices helps ensure code changes are managed effectively, updates are well-documented, and the quality of the codebase remains high. Regular code reviews and proper branching strategies make it easier for teams to collaborate and keep the project on track. Reviving and restructuring a codebase can seem like a big task, but taking small, planned steps makes it manageable. Start by checking the current state of the code and making a list of areas that need work. Set clear goals and create a plan to improve the code, step by step. Using the tools we discussed here can help find issues, suggest changes, and even automate some tasks. Version control practices, such as branching strategies and code reviews, keep changes organized and ensure the quality stays high. With a solid approach, even the messiest codebase can become clean, efficient, and easier to work with.
freeCodeCamp
Tue, 29 Oct, 6:32 PM UTC
How to Perform Code Reviews in Tech - The Painless Way
Okay, I know you may be skeptical: other guides have promised painless only to reveal that their solution requires some hyper-specific tech stack or a paid developer tool. I won't do that to you. This guide provides a straightforward and flexible template for that you can apply to your engineering team. The only requirement is that your app code is . You can test a TypeScript workflow, Java workflow, Python workflow, PHP, Ruby or even some wacky web stack you invented. And it doesn't matter if you're developing on Windows, Linux, or Mac. Best of all, you don't have to perform convoluted configuration or install software beyond a . I've been in engineering for the last 15 years, and have a bad reputation. We've all witnessed or lived through horror stories where sometimes it feels like every previous line gets torn to shreds. So, what can you do differently? How can you make reviewing your code painless so that even the biggest nitpick on your team has nothing but praise? After participating in code reviews for a decade, taking code reviews less personally is the single biggest thing you can do to improve your code. Why? Because all software is iterative. Even "perfect" code will eventually become outdated. Instead of thinking of it like a graded assignment, think of it as a part of the process. This tutorial uses free, open-source tools. You'll need to have a GitHub account to help you make your code reviews more pleasant and valuable. The term "code review" can refer to various activities, from simply reading code over your teammate's shoulder to a 10-person meeting where you dissect code line by line. I use the term to refer to a formal and written process, but not so heavyweight as a series of in-person code inspection meetings. In a project where you work on a repository with other developers, after you complete your work, you commit, push, and create a pull request on the VCS, most likely using Git commands. Then, everyone reviews the pull request to determine whether it's okay to use. If so, they approve it, and that code gets used in the project. Code Reviews are a tool for knowledge transfer. They help make devs more efficient when doing maintenance on a part of the system they didn't write. When you review a pull request, it's an opportunity to iron out issues before they become technical debt. Code reviews can also be a good setting for mentoring junior developers. Now, let's discuss what is not the purpose of a code review: Nitpicking on style issues - settle for one style and use formatters or AI tools to enforce it. Just keep in mind that there are many things that an AI tool cannot check. Code reviews are an excellent place to ensure the code is sufficiently documented or self-documenting. Do you want to know how you can check this? Return to the code you wrote 6-12 months ago and try to understand what it was written to do. If you understand it quickly, that means it's readable, and the code review was done properly and in a helpful manner. Despite their importance, many devs don't like doing code reviews - in part because they can be challenging, especially if you're not following best practices. Here are some pain points I've observed during my years of participating in code reviews: These pain points often bottleneck our development velocity. But recent advances in AI-assisted code review tools have started addressing these common friction points in our PR workflows. Let's explore how AI-powered tools, along with some best practices, can address these review challenges and optimize your development workflow. While AI hasn't replaced human code reviews, it is a powerful force multiplier in the review process. Here's how: AI code reviews excel as a preliminary screening tool, catching common issues before human reviewers see the code. This becomes especially valuable in open-source projects where maintainer bandwidth is limited. I recently started using AI code reviews on a case-by-case basis for my projects. AI tools improve my existing workflows, reduce failure rates by detecting logic errors early on, and boost productivity. So I've added it to my CI/CD pipelines. It doesn't have to be perfect at detecting logic errors, as long as its false positive rate is very low (ideally as close to 0 as possible). Most importantly, AI reviews respect the golden rule of 'value your reviewer's time' by handling routine checks. This allows human reviewers to focus on architecture, business logic, and complex edge cases. This approach positions AI as a complementary tool that augments rather than replaces human expertise in the code review process. When reviewing code, try to prioritise what matters most using the Code Review Pyramid. This is a framework that helps you focus your attention where it creates the most value. Think of it like building a house -- start with the foundation before worrying about paint colours. The pyramid has five layers, from most critical (bottom) to least critical (top): Remember: if you want to catch issues/bugs, there are more appropriate processes for that. That is why we have automated testing, canary releases, testing environments, and so on. In my personal opinion, using code reviews as a bug catching tool is somewhat of an anti-pattern where you're compensating for a development process that may be lacking some key steps/processes. There is no general rule in engineering for code reviews, as what you'll need to focus on depends on many factors. You can and should set up the process according to your company standards and way of working as a team. Here are some factors you'll need to think about before setting up a code review process: As an example, at my work we have a very simple rule: all code changes must be reviewed by at least one developer before a merge or a commit to the trunk. Code reviews need a systematic approach, but maintaining consistency across every PR is challenging. It's useful to let computers handle repetitive checks (style, formatting) while humans focus on what matters most: architecture and logic. This balanced approach makes reviews both thorough and sustainable. Take a look at this example. It shows how we can optimize our process by intelligently delegating tasks between humans and automated tools. The diagram below illustrates a typical code style review workflow, comparing manual human review steps against automated tooling. The diagram shows a real problem we all face in code reviews. See the left side? That's we humans doing manual formatting checks: finding weird spaces, fixing indents, writing comments about it... pretty tedious stuff. But check out the right side: that's where tools like just fix these formatting issues automatically. No meetings, no back-and-forth - just done. That's why I started using , which is a dev tool that caught my attention recently. The CodeRabbit docs describe the tool pretty effectively, so I'll just leave this here: CodeRabbit is an AI-powered code reviewer that delivers context-aware feedback on pull requests within minutes, reducing the time and effort needed for manual code reviews. It provides a fresh perspective and catches issues that are often missed, enhancing the overall review quality. - from the CodeRabbit docs Let me walk you through a real example. When you submit a PR, CodeRabbit: I first discovered last month while I was searching for something else on GitHub. I accidentally came across it and I was surprised by how many people are already using it. I instantly signed up because I was looking for exactly such a solution which could help me and my team out with our reviews. I read through the CodeRabbit docs and was very impressed. Getting started using it is pretty much a plug and play process. In the next section, we'll go through the quick steps you can follow to enable CodeRabbit using an example repo. Next, add CodeRabbit to some of your public GitHub repositories. Now, CodeRabbit is fully integrated and ready to do code reviews on your selected repo. Yes: it's that simple and fast. And in my opinion, it's one of the main reasons the tool is so useful. Here are some sample PRs for you to check out: Everyone's code needs reviewing. Just because someone is the most senior person on the team does not mean that their code doesn't need to be reviewed. In this article, I talked about code reviews along with some common pain points. I then showed you how you can leverage CodeRabbit to iterate quickly through your code reviews and focus more on business. In this article I talked about basic intro to CodeRabbit, because that was my use case with my blog. For more advanced functionality, check out the official CodeRabbit docs or read their blog. I hope you found it helpful learning how to use AI tools for code reviews. If you like my writing, these are some of my other most recent articles.
freeCodeCamp
Wed, 4 Dec, 12:33 AM UTC
Moderne raises $30M to solve technical debt across complex codebases | TechCrunch
When companies take shortcuts to build their software stack, prioritizing speed and quick-fixes over quality and long-term scalability, they can end up with what's known as "technical debt." Essentially, if a codebase is not constructed properly, as it grows, it will become more complex, cost more to maintain, and it'll become ever harder to add new features. And as with most kinds of debt, the problems can grow exponentially if left unaddressed. This is something that Moderne is setting out to solve. The company analyzes all the components that make up a company's stack, handles framework and library migrations to ensure that they're up-to-date, fixes security vulnerabilities, and even upgrades older tech to modern cloud-native equivalents. Built atop OpenRewrite, an automated code refactoring ecosystem that helps developers make large-scale changes across codebases, Moderne is the handiwork of Jonathan Schneider and Olga Kundzich (pictured above) who respectively served in senior engineering and product management roles at Pivotal, which VMware acquired for $2.7 billion in 2019. Prior to Pivotal, Schneider was senior software engineer at Netflix, where he helped create Rewrite, an internal project focused on automating the refactoring of Java code. This project eventually morphed into OpenRewrite and went open-source, with big-name adopters in hot pursuit. Indeed, back in October, Microsoft announced the GitHub Copilot upgrade assistant, which leans on OpenRewrite as part of an AI-enabled tool for updating Java apps. Amazon's AWS announced a similar integration as part of its Q Code Transformation tool back in 2023. But while OpenRewrite provides a powerful foundation to automating the code refactoring process, Moderne turbocharges it with features to make it more scalable across an enterprise setting. The startup offers support for multiple-repositories and more complex workflows; collaboration via a web-based user interface; and reporting and analytics. Founded out of Miami, Florida, in 2020, Moderne has so far raised around $20 million in funding. Today, the company is adding a further $30 million to the pot via a Series B round led by Acrew Capital, with participation from Allstate, Amex Ventures, Intel Capital, Mango Capital, Morgan Stanley, TIAA Ventures, and True Ventures. Moderne claims just 50 employees today, who Schneider says, are mostly "seasoned experts in every functional domain," enabling it to keep a lower total headcount. With the fresh $30 million, he says he's now looking to better cater to specific domains like application security (AppSec), having recently hired its first chief information security officer (who will be formally announced later this week). This expansion also guided Moderne's decision around its lead investor -- Acrew Capital founding partner Mark Kraynak has traditionally invested in cybersecurity companies. "We selected Acrew and Mark for this round with the intention of really building up that muscle of AppSec auto-remediation," Schneider told TechCrunch. Much has changed since Moderne raised seed funding back in 2021. At the outset, the company was substantively about "code modernization," but it has evolved into what Schneider calls "tech stack liquidity," which refers to any change a business wants to achieve across its whole codebase. This might be cloud platform migration, switching feature-flag vendors, or trying to avoid database vendor lock-in. Often, this kind of work would be carried out by consultancy firms who would parachute in and painstakingly comb through a company's codebase repository by repository. This "manual work," Schneider says, is Moderne's core competitor. "This is a multi-billion-dollar problem across the industry that Moderne is ideally suited to address," he said. Like just about every tech company today, Moderne is also benefiting from the large language model (LLM) revolution. Last year, the company introduced "AI-assisted auto-refactoring," which promises the necessary "accuracy and efficiency" to transform code at scale across multiple repositories. This sits in contrast to LLM-enabled coding assistants that you might see in GitHub's Copilot, for instance, which is more about local, context-specific code snippets rather than giant codebase transformations. Schneider says Moderne was well-suited to LLMs due to OpenRewrite's Lossless Semantic Tree (LST) code representation -- a structured representation of source code that enables deeper semantic understanding while retaining the original details (e.g. whitespace, comments, and syntax). Originally, this was designed for an OpenRewrite feature called Recipes, but it ended up being the "ideal data source" for what OpenRewrite is now doing with AI. "These [LLM] models are data-hungry, and LST has proven to be an invaluable data source for code," Schneider said. "The LST captures deep structural and semantic context across thousands of repositories. This unique capability allows Moderne to fuel AI models with vital context, enabling agentic experiences that can drive modernization, security, and code analysis efforts on a massive scale." It's worth noting that Moderne also transitioned its main web domain from ".io" to ".ai" last year, signifying that it's now very much an AI-centric company. "The move to the '.ai' domain [...] reflects a strategic evolution," Schneider said. A quick peek at Moderne's customer base is telling of who is most likely to benefit from its technology -- companies like Walmart and insurance giant Allstate. Its investor base includes names from the enterprise world such as American Express and Morgan Stanley, which, while unconfirmed, is safe to assume have invested strategically. But it's not just about gargantuan enterprises with unwieldy code sprawl -- Schneider notes that his company's smallest customer has just six developers. Plus, even once a dusty-old enterprise stack has been given a Moderne makeover, it doesn't mean the job's done. The "optimal" tech stack is constantly evolving: new components replace old ones, and best practices shift in tandem. Put simply, technical debt is always going to be a problem as companies pursue that "north star" architecture. "Ask any tech executive if they ever reach that 'north star' before it moves," Schneider said. "Codebases are in a constant state of evolution, requiring updates, security fixes, consolidation, improvements -- modernization never ends. Ironically, the most modern tech stacks are the ones most susceptible to breakage from the rapid iteration of the third-party and open-source dependencies on which they rely."
TechCrunch
Tue, 11 Feb, 2:10 PM UTC
Your Daily Dose of Curated AI News
Don’t drown in AI news. We cut through the noise - filtering, ranking and summarizing the most important AI news, breakthroughs and research daily. Spend less time searching for the latest in AI and get straight to action.
