Thank you. Hello, and welcome to the NVIDIA AI Podcast.
I'm your host, Noah Kravitz. My guests today are Varun Mohan and Jeff Wang from Codium.
Codium is a code acceleration toolkit built on AI technology.
Codium currently has two main capabilities. autocomplete, which suggests the code you want to type, saving you time on everything from boilerplate to unit tests, and search, which helps you search through your repository using natural language questions.
Built on in-house models and infrastructure and boasting easy integration into the editors developers already use, Codium seeks to help software developers do more with the help of AI.
That's really just scratching the surface of what Codium can do now and what its vision is for the future.
So let's turn to our guests to learn a little bit more about how AI is empowering the next generation of software developers.
Varun Mohan, founder and CEO of Codium, and Jeff Wang, business leader at Codium, welcome to the NVIDIA AI Podcast.
Thanks for having us. Thanks for having us.
So Varun, I'm going to throw it over to you to kick things off.
Why don't you tell us a little bit about How did the company get started?
And I'm sure you can give a better description than what I just read about what products and technologies you're building.
Yeah, so maybe I can give a little backstory about me.
Before starting, Exafunction was the company that built the product Codium.
I worked at this company called Neuro, and Neuro is an autonomous vehicle goods delivery company.
So their work firsthand on large scale offline deep learning infrastructure.
So building deep learning software at scale to make sure that cars could drive themselves.
So we started ExaFunction roughly two years ago, mostly with the premise of optimizing GPU workloads.
So we take large-scale GPU workloads. A lot of these workloads were at autonomous vehicle companies. we'd optimize them to run on fewer gpus and this was extremely critical at the time because there was even more a massive gpu shortage at the beginning of the During the pandemic, actually.
Right, I remember. So we were able to optimize... large GPU workloads, we ended up managing over 10,000 GPUs in the public cloud.
We ended up managing for one large cloud provider more than 20% of their entire GPU inference workload entirely.
So it was extremely large. But we realized that a year ago, a large chunk of GPU workloads were going to end up being in the form of these new general AI applications.
And one application we really enjoyed using at the time internally at the company was GitHub Copilot, which is this autocomplete tool that GitHub basically had it out in preview.
And we basically decided we were going to take our expertise in optimizing GPU workloads and probably go out and vertically build out an entire application, which ended up being Codium. felt that AI was going to have a revolutionary impact in software development.
And Copilot was probably just the beginning.
And we thought we could very quickly build out a large chunk of the stack at the same time, leverage the deep learning expertise we had in the company to build out applications that were scalable, not only for a large chunk of users, but for enterprises in general.
Got it. So you had the GPU virtualization and the infrastructure behind that. successfully running, saw an opportunity to build an app, a killer app, if you will, but one of many as generative AI is unfolding. but to build a code assistant tool that not only you know, does its thing well, but leverages the infrastructure you'd already built out in ExaFunction to do it even better.
That's right. Very cool. Yeah. A lot of our customers ask us, how are you giving this out for free?
And a lot of it just comes from that experience of optimizing GPUs and making sure it's easy to run these major workloads on. and then from that that led to our enterprise product right how can you self-host this locally, right?
Again, a lot of this comes from the expertise of exafunction and how do you manage GPUs.
We're here mainly to talk about Codium, but the two are intertwined and I don't wanna get too far off target, but I'm curious, When you talk about optimizing GPU workloads and sort of if I understood correctly, kind of squeezing more performance out of out of each GPU.
How big of a gain are you able to see if I had a very large workload running on exafunction as opposed to just running on my own hardware.
Yeah. So we actually have like case studies about the product when we deployed it to other other companies internally, and some companies saw up to like a 30 X gain.
Wow. in terms of the total amount of compute saved.
And part of that is because GPUs are a little bit different than CPUs in that you can't just like shove all the workloads on the same GPU without running into constraints like limited amounts of GPU memory.
So GPUs have a tremendous amount of compute, a couple orders of magnitude more than CPUs.
But the reality is also there are some trade-offs here.
In terms of the amount of memory bandwidth, they might only have one order of magnitude more memory bandwidth. but they have two orders of magnitude more compute.
So it requires a little bit of a reframing of how you want to actually schedule workloads.
Batching becomes extremely important. How do I place workloads with different characteristics on the same compute?
It ends up becoming a little bit of a challenging problem, but if you end up solving it properly, you get pretty significant wins.
That's fantastic. All right, so Codium. So you guys were, you had this infrastructure going, we just talked about, and GitHub Copilot came out, fans of that.
Was the motivation just to see if you could build something similar to Copilot that just was faster, or are there other things that Codium does that Copilot and other code completion tools out there don't do?
Yeah, so why don't we talk about that? A little bit of the story.
So when we started, we just wanted to build something that people loved using.
So we originally built the autocomplete product and it still is for individuals entirely free.
So we actually released it end of last year.
We currently are at hundreds of thousands of users on the product on track to hitting hopefully above a million users this year using the product so it's an entirely free product autocomplete is a very interesting problem for us in general so just to talk about a little bit it's a product on every keystroke you're going out and you're doing sort of a large language model computation on a remote machine.
And you're basically doing trillions of computations for every keystroke for all the users that exist.
So you can imagine it's an extremely challenging sort of infrastructure problem to sort of host.
And we decided we would sort of tackle that and provide that offering entirely for free to a lot of users. we didn't want to just be an autocomplete product when when we sort of built the tool we wanted to be a comprehensive generative ai toolkit and that's sort of why if you look at our product suite It actually is not only just autocomplete, there's also a natural language-based search component and also a chat component as well.
Now where Chad is also contextually aware of what's happening in the code base and can actually respond to you in a grounded way.
Okay. One of the very unique things, and we'll maybe talk about this a little bit more, is we also provide an ability to fine tune on the user's code base itself.
So our goal is to make sure that at any given point for an organization, we can give them the best experience for that organization.
And we thought that there was a lot of room in this area in particular. what languages or how many languages do you support?
Yeah. So one of the nice things about these generative AI models is they can support... It's kind of amazing what they can sort of do.
Like... if you look at some of these open models they can support many different languages like human languages they can support like chinese korean english we actually support now well over like 100 languages for the product and we work on over 40 ids as well So Varun, forgive me if you mentioned this a moment ago, but when did the product release to users?
Yeah, so we actually did a proper general release in December of last year.
Okay. But we started out, it was like a fairly small release.
You can imagine everyone was on break. So we started out the year with, with, with, you know, around less than 1000 daily active users.
But now it's sort of gone to in the last six months, it's gone to hundreds of thousands of users.
That was the question I was hoping to get to.
That's a sharp growth curve, even for the tech industry.
How did that happen so quickly? What do you attribute to it?
How can you tell us the story of how that happened?
It's actually an interesting thing where we've tried a lot of things to understand why the growth sort of happens. what we could do to improve growth it's basically mostly been word of mouth we've even noticed things which is kind of interesting where as the product has gotten better It has been supported in more ideas, more languages.
The growth curve has been improving, basically.
So one unique thing about our product is... we understand developers are extremely tied to the tools that they sort of have.
Like let's say we have a developer that programs in Vim. that developer is going to take a lot of effort to move them off of them because they've iterated their whole life on that or a lot of their tools are on there.
So we want to meet developers where they are and We make sure that we have extensions that work on virtually every IDE.
So we sort of see our growth ticking up and up as we support more platforms, make the product net better and add more features to the product.
And one very interesting thing that I can say is we started out end of last year with some of the open code models that existed.
There were other open generative AI code models.
And we quickly realized that some of those models weren't the best for an autocomplete product.
I'll maybe give you an example here. One thing when people are writing code that's extremely important is, they actually have context below the code too.
So let's say I'm editing a line. There's more context in the function below.
And basically, what you want is you want to solve this task that's called a fill in the middle task.
You want to be able to fill code in between contexts before and after.
And that actually requires a virtually different way of training the model.
And not only that, it required us to tune a lot of components to make sure that that ended up working.
So for us, we realized that it took us some time to make a good high quality fill in the middle model that our users were able to enjoy.
And from there, we've been able to apply different ways of making the experience better and better that sort of is not exactly tied to what the open source really wants to do, if that makes sense.
So we sort of have... over the last six months not only improved the product, gotten it out to more people, but we've tried to do new things to make generations even better for our own users, basically.
So the fill in the middle model, how much context is it able to take in at once?
My own admittedly somewhat limited, like a lot of people probably.
My interest in LLMs, my usage of them spiked.
And I was in the rabbit hole for a month or two.
And then it's ticked back a little bit in recent weeks. at my very novice level of using them um you know the the whole trick of getting it to understand the full context of my question, right?
It's an interesting thought process of going from, okay, wait, I need to figure out what the context is. and then figuring out how best to communicate that in a chatbot environment, for instance, and figuring out where to put the prompt and where to put the date, all of that, is that a similar process that you went through sort of abstractly or i don't know i don't want you to give away in the secret sauce so to speak but but how do you approach that problem Yeah, I think maybe for the autocomplete problem in general, the way we like to think about it is we want a model that is in some sense omniscient.
It knows sort of everything about the code base, which is really hard for an enterprise, which we can talk about.
But at the same time, it understands your intent and sort of where you are in the code. one very interesting things about these CHOP models in general and CHOP models are great is they're not built to sort of, in some sense, fill context in between two lines of code.
That's not the objective of these models.
I think one thing is for us as a company, we're squarely focused on for every product we deliver, how do we make sure it's like the best product and experience for that user.
And that's sort of why we can talk about this.
When we train our models even, We try to train them so that the latency is great.
We're able to fill context in as effectively as possible for our users and give them the best quality generation, basically.
But to your point, training large language models, the more data, the better.
But there are a lot of tricks that we do with context and eventually we'll talk about fine tuning as well to improve the suggestions as well.
But there are emergent kind of capabilities from these language models that come out unexpectedly.
You can do unit tests, for example, right?
Is that something we were looking to do?
And if you write a comment that says, like, write a unit test for this and that, it pops up, right?
And then when you look at the chat language models, you get things like, oh, can you optimize this code?
And then somehow it knows to make this code better right can you debug this code somehow it knows how to debug the code right um so it's really interesting language models like there's a lot of things we target And there's things that we can do that other people can't do either.
But then all these other features are just presenting themselves randomly, right?
It's truly amazing. I want to ask about the emergent abilities that come up and you're using phrases like, but it can do this or it can, so that it is the core LLM
Yeah. So I think, I think maybe one interesting thing is like an example here is.
The foundational, I should say, the foundational model.
Yeah, when these foundation models, right?
It's actually kind of interesting in that Some of these models, let's say, are able to, you ask like how many programming languages at some point are these language models capable of writing?
But we sort of have a model now that can write well over 100 programming languages.
And that's kind of interesting because Clearly, not all these programming languages are as popular as some of these other programming languages, right? language like C++ is significantly more popular than Rust.
But the model is actually really good at writing Rust.
And it's kind of interesting in that Rust foundation is kind of similar to C++.
There's definitely some some new primitives and and rust that C++ doesn't have that are net positive to programmers.
But because of that, it's able to take, in some sense, the learnings, the semantic understanding of C++ and the differences that Rust has from the training data and still be really effective at writing Rust. interesting properties here where it is actually better to have a singular model that is capable of sort of writing code in a variety of languages and just many distinct models, actually.
So when there's an emergent feature or even, I don't know if you would call that discovery that it's really good at writing Rust code, an emergent feature, or what you would call it.
But when you find something unique, right, that it can do a unit test, it can actually write really good Rust code.
Are you able to then kind of hone in on that and fine train your models and I see you nodding.
And so if that's a yes, is that by virtue of feeding it more of a certain type of data or how are you able to kind of fine-tune what you're using to write really good Rust code as opposed to how someone might fine-tune the model for I don't know, more general purpose use or to focus on written conversational language as opposed to coding.
Yeah, so one super interesting thing is actually for our product, we actually have a chat component too.
This is a chat component that now has like... basically hundreds of thousands, maybe close to a million usages sort of a day right now.
And one very common thing people like to do is generate doc strings.
So they love to take functions and generate documentation.
As you can imagine, the larger the code base, the more you need documentation to make sure that anyone understands what's going on.
So for us, we sort of realize how valuable this is as a tool.
And we can see from our individual users how high their usage is And we're able to basically tailor make sure that the models that we have for generating documentation are actually really high quality.
And this is something which we uniquely are able to do because of the sheer amount of usage we have.
And we can see, hey, when we generate documentation for a user, is that user actually accepting the suggestion?
And is that something that they genuinely want in their code, basically?
So maybe to break down the three products, autocomplete is by far the most used product.
Maybe talk to that a little bit, but autocomplete is basically a tool where like, as you're writing code, passively is generating suggestions for you as you're writing code on every keystroke.
So it's one of those things where at some point you're interacting with it so frequently that And the amount of value that we generate for each developer right now is probably the highest from autocomplete.
And in fact, people, in fact, change their behavior once they start using autocomplete for the first time.
Maybe I can explain. In the beginning, it's purely a tab tool.
It's a tool where you're writing code. It's saving you time, and you're just writing top, right?
But over time, what people do is they start documenting their code more in the hopes of, I wrote a common string or I wrote some documentation.
They press new line. And then they're just kind of exploring to see what gets auto-completed.
So there's basically two components here. an acceleration component where I'm just blazing through my code.
And then there's a second exploration component where the tool itself, you're sort of writing code in a novel way to make sure that the tool is providing as much value to you as possible.
So I may be misunderstanding here, but are you able to write documentation and then. have code generate the code to match your document.
Got it. Okay. Yeah. And that's sort of where things like the middle and all these are. are really helpful, right?
It's trying to use all the context that's present to sort of give you the best quality suggestion there.
And because of that, you're able to write net new code that you didn't even know you could write.
The exploration phase, right? Because at that point, it wasn't just an accelerating code that you already knew.
So that's maybe one. And our usage there, actually, just to maybe put up some numbers, we process over like 10 billion tokens of code a day, which roughly comes out to billions of lines of code a day. more than a billion lines of code a day that we're processing for autocomplete for individual users.
So it's, it's quite a bit, actually, it's maybe one of the based on some rough back of the envelope, might be like one of the top five LLM applications that is sort of being hosted right now.
It's like that big a sort of workload. This might be getting ahead into talking about the enterprise use cases, which we're going to in a moment, or we can just kind of transition to that now.
But I'm wondering about that sort of quality, but specifically the safety of the code.
This is an area where I might get a little out over my skis in terms of using language that I might be using imprecisely.
So please correct me when that happens. But when somebody, you know, I know when I was down the rabbit hole a couple months ago and I was having... you know, chatbots generate code for me to, well, different scenarios.
And I have done enough coding to be able to understand sort of basic code, but you don't want me writing anything, let alone approving something to go into production.
But my understanding is that there are concerns about AI-generated code that's just sort of been put into production, put out on the web in the wild by people like me who don't really know enough to know what we don't know.
And then that could start creating cybersecurity issues.
The code is not, you're not in your head, you understand.
How do you approach that as a company that's created an auto-complete tool?
Let me point out that a lot of what ChatGPT has come out, people are just like pasting things or... putting up a chat tbt interface directly to customers these are kind of dangerous things but The reason why we structured Codium the way it is is so that there is a human in the loop to verify everything that goes through.
So if there is a code that appears You had to you are human is reading it and hitting tab to accept the suggestion.
Right. And this is actually very intentional.
We are choosing use cases that humans should be verifying before they are putting in.
And if you imagine some product saying like, oh, let's expose this GPT model in front of a customer and just let it go at it, right?
There's inherently a lot of risk there, right?
Or if you have it generate like these massive documentation, I don't know that... or you're just putting it out there.
You don't know exactly what is going to happen.
So what we do at Codium is to create products where there is a high degree of verification and accepting before it goes through.
In terms of generating good or bad code though, again, there is a human in the loop to verify whether or not they should accept that code.
Hypothetically, and not focusing on codium per se, but just kind of to your point, Jeff, Let's say there's a human in the loop.
Let's say that I somehow, I asked it in the documentation.
I use that exploratory feature. and I wrote documentation for an app that does whatever, it doesn't even have to be nefarious, just does something, right?
And let's say that you know, the code generator, not coding, but just some code generator generated code.
And I just sort of either blindly or I'm just not that good at reading other people's code and accepted it and put it in production.
And there were issues with it. When people talk about safety and security issues, are the issues mainly that the code could be easily exploited, and that's the biggest issue people are worried about?
Or what are the issues when we hear terms like, ai safety as it pertains specifically to ai generated code i think there was an article that was recently released by i think it was wall street journal that said that the code generated by AI is not as high quality of code and that people are blindly putting it out.
I actually don't. think that's true i would think of this as more of a productivity tool that helps a developer come up with things that they're already going to do.
And then when it appears on the screen, the developer should have the competency to see if that's the correct way to implement it.
I think it'd be very rare for a person to just output a block of code and just blindly submit it.
And then the code reviewer to just blindly accept it.
There are still processes in place to ensure that the code generated by all these AI tools should be accepted.
Yeah, I think maybe to hammer that point, there's an entire software development lifecycle where you have to unit test your code, you have to document your code, we're going to be the first people to say, this is not a tool that replaces humans, which is quite important. do a lot of things to mitigate this, right?
Like when we train our models, we already do this.
If we realize that there are security exploits with a particular library, we can just not include these libraries into our training set.
And then on top of that, for enterprises being able to fine tune on their own private code, grounds it so that the model is generating code that is semantically relevant with the code in the rest of the organization so those are things we can do but all these things are mitigations that users need to sort of review things that come out of generative models.
Makes sense. I'm speaking with Varun Mohan and Jeff Wang of Codium.
Varun is the founder and CEO and Jeff is the business lead at Codium.
As we've been talking about, Codium is a complete code acceleration toolkit that leverages AI
For autocomplete functionality during coding, as well as search and chatbot functionality, It's a complete set of acceleration tools to help developers code faster, take care of documentation faster, basically everything involved in writing code.
Codium is out to leverage AI to make it better.
So we've referenced it a couple of times, but you guys have an enterprise product.
And I wanted with a little bit of time we have left to get into how the enterprise product works then talk a little bit about, as you were just mentioning Varun, fine-tuning a model, training it on your enterprise code base and kind of what that means, both technology-wise, but also what it offers to the enterprise customer.
Yeah, so maybe Jeff can chime in afterwards.
But we recognized that we had this massive individual product.
It was very quick that enterprises really just wanted to run the product themselves.
This was because I guess one thing is code is extremely important IP for most companies.
This isn't something that they want leaving their own firewall at all.
That coupled with all the concerns about There are vulnerability leaks from GitHub.
ChatGPT has some leak and is banned in a variety of other companies.
Google themselves actually told their own employees, don't write personal information into Shopbots and that includes their own software.
They themselves released a chatbot called Bard.
So this is definitely one of those things where even the companies releasing these products themselves are saying, hey, don't put first private data inside here. just to clarify for the audience, with the concern being that if you input sensitive data, it could be rolled up and used in the next training set and then An LLM down the line could spit it out in response to one of your competitors asking the question.
That's right. And it's probably especially important for code where code has very specific IP.
You can imagine for hardware vendors, this is not something they want leaking.
For people that are Forget about hardware vendors, they might have information that is private to business negotiations and how they market the product that definitely should not be public.
For all these reasons, companies don't want to send their private data outside if it's possible and do want to self-host an offering that basically gives them code intelligence.
So we wanted to give people the flexibility and this is where us being the largest deployment of our own product is very important.
We have so many individual users. We have way more individual users than any single enterprise will have in terms of number of developers.
Our enterprise product is tailor-made to satisfy the security needs. is definitely one thing, but I also wanted to make sure that the reason the enterprise product is also unique is we wanted to make sure that the only value add wasn't security.
We were able to truly deliver them the best product for the enterprise.
And that's where personalization and fine tuning sort of comes in.
Large enterprises have written millions of lines of code internally.
And one key thing is these models, when it comes to context, and only take in maybe hundreds of lines of code as context.
Maybe a good example here is products like Copilot currently can do 2000 tokens of context.
And that's like around 150 to 200 lines of code.
Some of these bigger models, I guess when GPT-4, which is really great reasoning engine and do 32 000 tokens of context which roughly comes out to four files of code, whereas large enterprises have hundreds of thousands of files of code.
This is not a sustainable approach to giving the best quality generations.
There's also a latency trade-off here. The more context you shove in on every generation, The generation is going to take minutes to come back.
So we wanted to make sure if we are self-hosting an offering, The offering that we're providing to the enterprise is personalized.
It's in some sense, semantically understands all the code that has been written inside the company.
And we're not just, I think, trying to sell an offering just because we can.
Meta as a company actually was in talks with GitHub Copilot to sort of use the product.
They not only said no for the security reason, the other thing is they wanted to be able to fine tune on all the private code that they sort of had.
Right. They actually published a paper on the system that they built called Code Compose.
And they saw that acceptance rates and quality of code went up by over 20%. with a fine tuned model.
Using a fine tuned model, right. Yeah. And by the way, this is on a base model that's much smaller than Copilot also.
So with an even more inefficient model, but fine tuning with your personal code, it actually performs better than the large model, right?
And it's funny, like a lot of customers ask us like, oh, what if I have bad code?
Or like, what if I don't want to expose some code to other people?
Like it comes back to what Rune was saying about Rust and C++, like the best practices and the inherent structure about programming is still there.
But adding your code on top of it will give it additional context and give it references that would never have appeared if you were using Copilot.
What do you do for companies like this who want to fine train their own model?
And exactly as you both were just saying, they want both the performance boost, but also the better privacy and security that they won't get with a public model.
How do you ensure these things, how do you run is it a localized instance and fine train it on their hardware and keep it within their firewall, how does it maybe walk us through a little bit how that works.
Yeah, we have the ability to host it either on-prem or in a virtual private cloud.
We've even deployed in such instances like GovCloud, So completely air gap from the environment.
But if you have your own GPUs sitting there, we wanted to do something with them, right?
So whenever they are idle, we are able to train on your code and fine tune the base model against the code.
And this is again, if any other company was to do this, they would have to reserve the GPUs out. wait for that idle time, and then kind of waste essentially a ton of hardware for these customers.
For us, we already are inside your instance.
So we want to utilize that to make sure that we are doing something productive.
And I think Meta even published the results that if they worked with Copilot to do this, it would have cost them like seven cents per query to just have this infrastructure set up.
So you can imagine it could get very expensive, but because Again, we talked about how we're optimizing on GPUs.
We're able to do this much smaller than other companies can.
We are able to host it as well as fine tune it in the same instance.
And so is there an equivalent cost per query?
You know, that seven cents, if it was hosted on Copilot, what would it cost hosted on Codium? it's probably hundreds or thousands of cents, thousands of a cent for each generation.
It's one of those things where for us, at least, to at least be able to offer a product like this for free.
And people do like hundreds, if not thousands of generations a day.
It's one of those things where we've had to optimize the workload a ton. ourselves, which comes again where we're one of the largest users of our own product.
So it helps a ton. So the return on investment for an enterprise-scale company with millions of lines of code in their repository, I mean, that's got to be huge. for if you've got fleets of developers over time, right?
Yeah, so actually it's very interesting.
We have studies on this because we have individual users that are willing to share some information about their usage.
And just from the typing alone for code completion, we save our users between 5 and 10 hours of typing alone in a month.
That's just typing. Ignore the fact that we are reducing cognitive overload.
We are generating code that they didn't even know would have been feasible to generate.
And then if you couple that with fine tuning where the real issue with these large enterprises, most of the code that they write is not code that is copy and pasteable from the open source.
Not that you should be copying and pasting code, but most of it references code within the enterprise itself.
So because of all of this in combination, we're able to deliver, I think, a better experience, but also save even more time inside these companies so the roi for the tool in terms of productivity is is immense basically Yeah, that's fantastic.
So that kind of leads me into kind of ending on sort of a future-looking note.
And I'll ask you guys in a moment about Codium and kind of the future of the company and Exafunction as well.
But staying for a second in the mindset of a software developer and using a tool like Codeion And I'm saving five to 10 hours a month just on typing, let alone the cognitive load.
And I would imagine there are aha moments where I'll autocomplete and Codium will write the code in a different way than I was imagining it might.
And I don't know how subtle or non-subtle that is, but I would imagine also there are things you can lump into productivity gains from those sort of of mental moments of, oh, wow, doing it this way.
And then I do it that way. The rest of the code block, it saves me time.
Looking out ahead, you know, a year, two years, I mean, things are moving so quickly right now, it's kind of hard to put a timeframe on it.
What do you think the role of the software developer, how will that change And I know that there are different types of software developers, different roles.
You're managing a team, you're an individual contributor, you're an architect, different things.
So run with this where you will, but how do you guys see the role, the process of software development changing because of tools like Codium?
Yeah, I think what's probably going to happen is more and more software is going to get generated by AI, but one of the things that I think is holding back so much software getting generated by AI is what you said.
Things like hallucination, making sure that the quality of the output is high quality and actually doesn't have security vulnerabilities in it. part of the thing i think it needs to happen along the lines is making sure that code that gets generated passes unit tests making sure that code that you know at If any net new code gets written, unit tests are written, right?
So I think what really ends up happening in the future is more code will get generated but also more the code that needs to get generated, you will need to build equivalent verification systems.
Right now, part of the verification system is you're not generating an entire PR and because you're not generating an entire PR, developers that are writing the code can actually validate that what they're writing is correct.
But I think as more and more code gets written, building out more pieces where, hey, I generated some code.
The system itself asks you, I'm going to be running a unit test. and you actually accept, you run the unit test, you look at the output of the unit test, and the output says, hey, you failed all these unit tests.
And the system is kind of iteratively saying, oh, given the output of the unit test, I think I need to modify my code a little bit.
So it's going to be this kind of iterative approach where more code gets written, but also humans are the driver seat. of that entire process.
But I guess their leverage is higher and higher with time, if that makes sense.
And what about on the business side for you guys?
We're recording this in June, mid-June of 2021.
2023. And it's been quite the six months or, you know, I'd imagine leading up to that as well for you guys publicly, these six months have seen your your growth just explode like we talked about so what are you working on i don't know the rest of the year into next year again whatever whatever time frame uh the roadmap you're willing to share.
Yeah, I think the key thing we want to focus on internally is, so we have a bunch of individual users that we want to make sure we're always delivering them the best experience, but how do we generate... deliver the most personalized experience for enterprises is something that we are extremely focused on.
This is a uniquely, I think, challenging problem because enterprises have tens of millions of lines of code.
This is much more than a single open source repository for most repositories.
So making sure that that experience and there was still a massive productivity gain there. something that we're focused on.
So finding out all the places in the software development lifecycle that we could be helpful.
And trying to make sure that in large codebases, we're still providing value is squarely what we're focused on.
We've also talked about fine tuning code, but what about fine tuning against documentation or system design or you plug in your Confluence and you get a whole bunch of other additional context that could help writing your code as well.
These are all things we're looking into.
So like expanding beyond code, but focused on making the whole software development lifecycle more productive for the whole company.
Excellent. Well, guys, this has been great.
We covered a lot, but also kind of only scratched the surface of all the different things that you're working on and and more so just the future of what generative AI is gonna mean to software development.
For listeners who want to stay up on the latest, I know Codium has a pretty active blog from what I saw.
Where are some places, the website, maybe social media, anywhere else that listeners can go to find out more about the company and then obviously if they want to give Codium a try.
Yeah, I would say go to codium.com. That's codium with an E. Just make sure that that's clear.
So C-O-D-E-I-U-M. right you could follow our discord in there you can follow our twitter but really we encourage everyone just install the free product and try it for themselves and when i say try It actually just means you own it.
Like you have it for free forever. Right, right.
Individual user, it's free. Enterprise situations are where money gets involved, but individual user, you can just try it and keep it. maybe one last thing because there's a little bit of uh people people have some concerns there is Even if you're a company that you're an entire company, you can use the free product.
We have like no issues with that. uh as well i think it's just for us if you do have a self-hosting requirement that's the only that's the only time it becomes an enterprise product Got it.
Can't beat that. That's great. Varun, Jeff, guys, thank you so much again for coming on and telling the story and sharing a little bit of insight into this wild world of software eating software, AI eating software, eating the world.
I don't even know what the the cliche is these days, but we appreciate it.
And all the best this year with continued growth and success, helping people write more and better code faster.
Awesome. Thanks for having us. ... ...
