CodeOps: Using LLMs and modular coding to accelerate development

In 2009, DevOps emerged as an operational model for teams that wanted to realize the full potential of rapidly evolving Agile software development methods. It enabled these teams to deploy as quickly as they could build, establishing a new paradigm for fast, iterative development.

In its wake came a global explosion of software production, and with it, related frameworks like DevSecOps, MLOps, AIOps, DataOps, CloudOps, GitOps, and more. For any engineering function or core development technology, there’s an operational framework and market category to optimize it.

So why, with so many solutions available, do enterprises still struggle to convert this abundance of “-ops” strategies into satisfactory speed and innovation outcomes? And how, as organizations continue to accommodate disparate sources of code (proprietary, open source, LLM-generated, etc.), can they adapt these models to what’s coming?

Enter CodeOps, an emerging way to build software products quickly with wholly owned and reusable code. It leverages generative AI and modular coding concepts to speed up the development process, enhance innovation, and, ultimately, drive faster digital product development.

How CodeOps works

Like Agile, the goal of CodeOps is to enable and accelerate software development within businesses. Rather than optimizing for agility, however, it optimizes for reuse—reuse of specifications, designs, architectures, data models, integrations, and, of course, code itself.

Reusing existing code has long been a natural practice among engineers. When applications look similar at the planning level, you can identify a usable architecture instantly and get a fast start on your codebase by assembling its core parts automatically. Good devs know this and will opportunistically reuse code components they’ve either developed themselves or found in open source repositories.

However, the impact of developer-level reuse is entirely dependent on the sophistication of the team, and there is usually no process or tool to ensure that it scales efficiently to provide benefits across the entire organization. That potential is only achievable via systematic reuse, wherein certified modules are made centrally available and discoverable for use across teams involved in app development.

Organizations looking to leverage CodeOps concepts should therefore be prepared for a paradigm shift. Systematic code reuse is a transformative step forward in the development process. It involves creating a centralized repository to house certified modules that have undergone necessary vetting and extensive testing to ensure functionality and security. The goal is to create a wide spectrum of modules that can be seamlessly deployed across diverse projects and teams.

Maximizing ROI with generative AI

CodeOps also readily accommodates emerging trends in hybrid human-machine development. Most teams today understand generative AI’s potential to act as an opportunistically integrated copilot. However, they aren’t sure how to project, track, and maximize its impact on business outcomes.

By reframing the way that teams build software, CodeOps provides a framework for understanding generative AI’s ROI. It prioritizes LLM usage as follows:

1. Composition of existing modules according to project specifications
2. Creation of new modules consistent with a strategic module roadmap
3. Generation of custom code for non-modularized use cases

LLMs already match or exceed human performance when it comes to module composition, which is the task of pattern-matching a stored catalog of modules against a custom product description or detailed specification. This method can dramatically reduce the “planning and alignment” stages of the conventional software development life cycle, and this reduction translates into time savings for non-technical stakeholders and shorter overall development timelines.

LLMs are also well-suited to the creation of new modules according to custom parameters. With sufficient prompt clarity (or a training set of an organization’s existing code), they are capable of generalizing a team’s existing code standards to the production of new, reusable specifications and code modules. An organization that has adopted systematic code reuse can thus rapidly populate their catalog of modules according to their internal code standards, driving compounding productivity gains on a much shorter timeline than they would via manual module creation.

Finally, CodeOps readily integrates “Copilot”-style AI code generation by individual developers. However, within a CodeOps discipline, this usage is helpfully constrained to the last mile of custom development that initial module composition can’t cover. This reduces the ROI fuzziness that teams face today: Some developers use AI a lot and some use it very little, but with CodeOps, you can identify the portions of the codebase where AI should provide your team with a productivity boost, then optimize accordingly.

CodeOps in practice

When it comes to reusing modules of code, there are two primary parameters to consider: coverage and reusability. Coverage refers to how much of a typical application consists of a certain module type, while reusability refers to the likelihood that a certain module type will be usable across different projects.

Here are some general rules for understanding coverage and reusability:

It’s important to note that the largest portions of an app aren’t always the most reusable. This distinction can help teams understand how to make the right tradeoffs when investing in module development. Within a CodeOps approach, module production should first be prioritized according to reusability rather than coverage to ensure maximum realized value.

To understand how CodeOps can impact a given project, let’s consider a sample personal finance application development timeline with and without CodeOps:

Without systematic reuse

Project duration: 28 weeks

Project breakdown:

• Requirement analysis: 2 weeks
• Design: 2 weeks
• Coding:
  • Authentication flow: 3 weeks
  • Payment processing integration: 4 weeks
  • Data validation features: 2 weeks
  • Reporting features: 3 weeks
  • Additional custom features: 6 weeks
• Testing and debugging: 4 weeks
• Deployment: 2 weeks

With systematic reuse (CodeOps approach)

Project duration: 16 weeks

Project breakdown:

• Requirement analysis: 1 week (reused spec)
• Design: 1 week (reused design)
• Coding:
  • Authentication module (reused): 1 week (integration and customization)
  • Payment processing module (reused): 1 week (integration and customization)
  • Data validation module (reused): 1 week (integration and customization)
  • Reporting module (reused): 1 week (integration and customization)
  • Additional custom features: 5 weeks (AI copilot-assisted)
• Testing and debugging: 3 weeks (fewer bugs and inconsistencies due to reused certified modules)
• Deployment: 2 weeks

It’s worth noting the whole-cycle impact of CodeOps. It increases productivity at multiple points in the process, across multiple teams, without requiring those teams to significantly modify their workflows.

Benefits of systematic code reuse

Implementing systematic code reuse creates several distinct business advantages, including:

• Enhanced flexibility: By granting development teams access to a repository of pre-certified modules using the organization’s code, they can customize it and create apps that perfectly fit their unique business needs.
• Guaranteed consistency: Systematic code reuse ensures uniformity across applications. Using identical certified modules by multiple teams minimizes inconsistencies and lowers the risk of encountering bugs, security vulnerabilities, or compatibility issues.
• Accelerated education: With systematic code reuse in place, developers can learn from and build on work performed by team members and colleagues. This creates an organizational knowledge base, accelerating the learning curve for new team members and breeding a culture of collaboration and innovation within the organization.
• Risk mitigation: Rigorously tested and certified code modules are proven and reliable, diminishing the likelihood of critical security or compliance issues emerging during development, testing, or post-launch.
• A commitment to innovation: By liberating development teams from constantly performing repetitive tasks, systematic code reuse encourages them to channel their efforts into new levels of exciting innovation. They can allocate more time and resources toward creating distinctive and valuable features with more predictable outcomes, while reducing time to market to generate new revenue or cost savings.

A better way to build

Ultimately, a CodeOps approach that embraces systemic code reusability transforms custom app development by doubling delivery speed, enhancing productivity, and fostering innovation and collaboration in a competitive tech landscape. Creating and innovating new products is the fun part of tech, meaning organizations that utilize CodeOps not only create advantages over competitors but also boost the productivity and morale of their internal teams.

Anand Kulkarni is CEO at Crowdbotics.

—

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