Latest / Code Story | Startup Podcast for CTOs, CEOs and Technical Founders / S12 Bonus: Rickard's Deterministic Return: Converting Scattered Data into Autonomous, Production-Grade Apps with Rickard Hansson, Founder & CEO of Gainable

Transcript

S12 Bonus: Rickard's Deterministic Return: Converting Scattered Data into Autonomous, Production-Grade Apps with Rickard Hansson, Founder & CEO of Gainable · Code Story | Startup Podcast for CTOs, CEOs and Technical Founders

• 0:00
  [SPEAKER_00]: Hello listeners, we have a special return episode by our good friend, Rickard Hansen.
• 0:06
  [SPEAKER_00]: Rickard joined us previously on the podcast and season eight to tell the creation story of Weeve, collaboration infrastructure for serious builds.
• 0:15
  [SPEAKER_00]: Today he makes a follow up visit to tell us all about gainable his new project, which removed data and engineering from being the middle man and enables your team to build the apps they need now.
• 0:28
  [SPEAKER_00]: Work our thanks for coming back on code story.
• 0:31
  [SPEAKER_00]: Thanks for being on the show again.
• 0:32
  [SPEAKER_01]: I'm happy to be back.
• 0:34
  [SPEAKER_01]: Happy to be back.
• 0:35
  [SPEAKER_00]: It's been a minute since we talked on Season 8 when you were building Weveed, but before we jump into our topic for today or on Gainable, tell me and update on Wevey.
• 0:45
  [SPEAKER_00]: What's happened since we last talked?
• 0:47
  [SPEAKER_01]: Wevey is checking along, Athema Churred, it's been going upstream with more enterprise focus, like big contracts and big clients.
• 0:56
  [SPEAKER_01]: I don't remember exactly how we covered last time, but we were like competing with
• 1:01
  [SPEAKER_01]: Sandbird and stream and so on so forth very consumerized focus, but During the journey we've been going upstreams and it's doing really well and I have to say we've In gainable or very tied together we can dive into that later.
• 1:16
  [SPEAKER_01]: I'm using VV in gainable because that's how we've Is designed to empower other applications and other frameworks and other platforms So obviously I'm using my own stuff and my own tech to to build a new company
• 1:28
  [SPEAKER_00]: Yeah, absolutely.
• 1:29
  [SPEAKER_00]: Okay, super cool.
• 1:30
  [SPEAKER_00]: Tell me about how you came to build to be building gainable from maybe the wevy to gainable story, but I'm curious about the pitch for gainable and tell me why this is the right approach for AI right now approach we had with wevy early last year.
• 1:46
  [SPEAKER_01]: It was to empower Vibe code applications using the WV components.
• 1:51
  [SPEAKER_01]: Anyone who wants to go back to this into the season 8 episode, just for WV in a short phase is collaboration components that you can embed in any application.
• 2:00
  [SPEAKER_01]: And it's been designed to be very easy to embed and completely self-contained.
• 2:04
  [SPEAKER_01]: So it's a perfect fit for Vibe code.
• 2:06
  [SPEAKER_01]: It didn't take off, because not the right kind of audience, the Vibe codeers.
• 2:10
  [SPEAKER_01]: But I got a very intrigued by the fact, okay, so by vibe coding platforms, why, back then, and I still think, why do they suck so bad?
• 2:19
  [SPEAKER_01]: Like, they, a couple of prompts in and start breaking down and why do they build so complicated applications?
• 2:27
  [SPEAKER_01]: Technically wise, when a user like me or anyone else just wants a networking app, doesn't have to be the perfect react code and
• 2:35
  [SPEAKER_01]: So I started experimenting, like building my own lovable or building my own replete, on my spare time, which is basically very limited, right?
• 2:42
  [SPEAKER_01]: And then that started maturing into a platform with a specific focus and a specific niche, and that was internal tools.
• 2:51
  [SPEAKER_01]: Everything you see right now, I think, in the vibe coding, phenomena and industries, very focused on building access, being millionaire overnight, or building websites, I trust something like that.
• 3:01
  [SPEAKER_01]: And obviously, you can build the internal tooling too, but the infrastructure and architecture doesn't really support it.
• 3:07
  [SPEAKER_01]: And I'm really intrigued by internal tools and I think that's a way bigger mark by the end of the day.
• 3:11
  [SPEAKER_01]: And then obviously using VV as a product to build very rich applications with few lines of code.
• 3:19
  [SPEAKER_01]: Instead of building very complex applications with a lot of lines of code because the AI is doing it.
• 3:25
  [SPEAKER_01]: So I started building that.
• 3:27
  [SPEAKER_01]: And then that matured into a framework or a platform earlier this year called Gainable.
• 3:36
  [SPEAKER_01]: It's more competing.
• 3:37
  [SPEAKER_01]: I will say we say companies like retool or apps may have for super blocks.
• 3:41
  [SPEAKER_01]: But it's taking the approach of a vibe coding, coding or whatever you want to call it to get up and running.
• 3:48
  [SPEAKER_01]: And when I started experimenting with gainable,
• 3:52
  [SPEAKER_01]: I actually decided to go the opposite direction.
• 3:56
  [SPEAKER_01]: Everyone was then bragging about using the latest model out there, Opus 4 or 5, whatever it was back then.
• 4:05
  [SPEAKER_01]: And then obviously they were bragging about like our coding agent just became 20% better.
• 4:11
  [SPEAKER_01]: Yeah, obviously because the LM got better.
• 4:13
  [SPEAKER_01]: So you didn't really do anything.
• 4:14
  [SPEAKER_01]: Your base prompt is still the same.
• 4:16
  [SPEAKER_01]: Your base instruction is still the same.
• 4:18
  [SPEAKER_01]: So I've shown myself like I want to be able to do what say lovable is doing but I'm going to use high coup four five.
• 4:24
  [SPEAKER_01]: The dumbest moment fast.
• 4:26
  [SPEAKER_01]: Can I get that done?
• 4:27
  [SPEAKER_01]: So I started there and I got pretty close but along that way I realized since AI across the board is probabilistic, right?
• 4:35
  [SPEAKER_01]: It's making up shit every time you tell it to do something it will generate different stuff every time.
• 4:41
  [SPEAKER_01]: which coding wise is not great, because sometimes it's work at the next time we want.
• 4:45
  [SPEAKER_01]: So I started leaning more more into creating deterministic snap-in, so to speak, okay, whatever, high-grade generated, I had to put a deterministic validator on top of it to say, oh, I need to snap these things into place because they're out of order.
• 4:59
  [SPEAKER_01]: I make basically fixing a jigsaw puzzle afterwards.
• 5:01
  [SPEAKER_01]: Like, it didn't really put this piece in the right place, but I can see it almost fits.
• 5:05
  [SPEAKER_01]: So let's just jiggle a little bit and put it in place.
• 5:08
  [SPEAKER_01]: That's what
• 5:11
  [SPEAKER_01]: So, and then I became more and more of those batteries.
• 5:16
  [SPEAKER_01]: I have almost a hundred deterministic validators around what the code is generated right now.
• 5:22
  [SPEAKER_01]: But then that turned into a compiler.
• 5:26
  [SPEAKER_01]: So, I don't use AI to code.
• 5:28
  [SPEAKER_01]: I use AI to build a spec that is falling a specific format I have.
• 5:32
  [SPEAKER_01]: It's basically a contract that defines, okay.
• 5:35
  [SPEAKER_01]: Now, I want you to draw a dashboard with these gadgets and widgets, and these are the sources I want you to create, and so forth.
• 5:43
  [SPEAKER_01]: It's creating a story in JSON format though.
• 5:46
  [SPEAKER_01]: And that is what they're all I'm doing.
• 5:48
  [SPEAKER_01]: But the coding is done by my compiler, and then a compiler takes over to create the application, everything from data models to crad API endpoints to the actually UI and widgets and all the different endpoints created.
• 6:00
  [SPEAKER_01]: So that means the build takes roughly 45 to 50 seconds.
• 6:05
  [SPEAKER_01]: But the cool thing it works every single time when you build, there's no errors, and it's building in one shot basically.
• 6:12
  [SPEAKER_01]: A application with eight, nine, ten different views, tell 12, which refer to different odd data models and crowd API and points that's also for with zero errors in the end.
• 6:23
  [SPEAKER_00]: So this is super interesting, and this ties into a point that we've talked offline about the point that you mentioned that AI Builders are standing on the models, right?
• 6:34
  [SPEAKER_00]: They're waiting for the next release of the models to fix the caps.
• 6:37
  [SPEAKER_00]: And from what you're describing, the model sits earlier in the workflow.
• 6:41
  [SPEAKER_00]: Tell me a little bit more about that, and gainable, where the model sits versus the compiler, and why is that the right spot for it?
• 6:47
  [SPEAKER_01]: This is obviously my opinion, but so yeah, it's earlier, right?
• 6:50
  [SPEAKER_01]: So then also how it design gainable, yes, you don't prompt to build applications.
• 6:56
  [SPEAKER_01]: You give it data.
• 6:57
  [SPEAKER_01]: Primarily I would say Excel sheets were Google sheets.
• 7:00
  [SPEAKER_01]: Because when I was talking to my potential clients,
• 7:03
  [SPEAKER_01]: and I ask them why you're not vibe coding this, why you're not replete or lovable of this application you're thinking about, it's like I cannot articulate what I want.
• 7:12
  [SPEAKER_01]: So, okay, so there's an articulation gap, like vibe coding is phenomenal.
• 7:16
  [SPEAKER_01]: You can natural language anything and so on and so forth.
• 7:19
  [SPEAKER_01]: And it's great for a person like me because I can code, I can describe a product.
• 7:22
  [SPEAKER_01]: but a quote unquote normal person cannot.
• 7:25
  [SPEAKER_01]: But I said, like you built this amazingly very complex Excel sheets.
• 7:29
  [SPEAKER_01]: So obviously you're not done, right?
• 7:30
  [SPEAKER_01]: You can do stuff, but you can still not bridge the gap between making that Excel sheet or that data point into an application.
• 7:37
  [SPEAKER_01]: So what Gainable does, and this is also why it turned out to be more LLM on the edges is it is, you feed it with a massive excelsiate, for example, and then the LLM, which will LLM, or great that, is doing judgment calls, analyzing, finding domain, or this is the CRM, this is sales, this is pipelines, this is inventory.
• 7:58
  [SPEAKER_01]: and start analyzing the data, and then suggest, do you want to do this?
• 8:01
  [SPEAKER_01]: Do you want to do that?
• 8:02
  [SPEAKER_01]: And that's where LLM comes into to the gainable pipeline, upload the data, and then opens for it in my case in this case.
• 8:09
  [SPEAKER_01]: Right now, at least, is analyzing that data and comes up with a lot of IDs, and then you just say, yes, no, yes, no recommended, and then when it has all that information from you, and you had to check out about it, it creates a data model around that.
• 8:24
  [SPEAKER_01]: And then next step is that data model is passed on to the next stage, which is also making decision.
• 8:30
  [SPEAKER_01]: But that model that ageing is designing an application, not coding it, not building it, but designing that application based on the data model.
• 8:39
  [SPEAKER_01]: So still, LLM is not coding anything.
• 8:41
  [SPEAKER_01]: And then the next step is creating that contract.
• 8:44
  [SPEAKER_01]: So it's...
• 8:45
  [SPEAKER_01]: So as soon as we've done with the contract and the design, it's handed over the compiler and LLM gets
• 8:50
  [SPEAKER_01]: So when you click build, LM is doing basically nothing.
• 8:56
  [SPEAKER_00]: Okay, so that makes total sense and has a really interesting movement of the LLM up the pipeline here.
• 9:04
  [SPEAKER_00]: And the engineer and me, I think, knows the answer to this next question, but I'm curious about.
• 9:09
  [SPEAKER_00]: the deterministic aspect of this.
• 9:11
  [SPEAKER_00]: Can you explain why that is important that having a deterministic act factory, right?
• 9:17
  [SPEAKER_00]: Dig into that for me, and how this sort of architecture creates that deterministic model.
• 9:24
  [SPEAKER_01]: When the contract is generated, so the contract is probabilistic, right?
• 9:27
  [SPEAKER_01]: Because it's going to make up different designs and do different judgments every time you run the same data set through it and then you're going to get the contract.
• 9:34
  [SPEAKER_01]: But the contract's specification, how it's built, that is deterministic.
• 9:39
  [SPEAKER_01]: So that means same input in terms of the contract format is the same in terms of how it's formatted.
• 9:45
  [SPEAKER_01]: That means the same output every time.
• 9:47
  [SPEAKER_01]: Every application looks different.
• 9:49
  [SPEAKER_01]: But how it codes it, how it puts pieces into place.
• 9:53
  [SPEAKER_01]: is exactly the same every single time.
• 9:55
  [SPEAKER_01]: So it compiles under the second and errors grow linearly, not productically like you do with the model round shape and so on.
• 10:02
  [SPEAKER_01]: So that deterministic approach is what let me trust, basically the first app and the 10,000 app, because it's just going to be the same.
• 10:11
  [SPEAKER_01]: every single time.
• 10:12
  [SPEAKER_01]: That is how that approach works.
• 10:14
  [SPEAKER_00]: Okay, so that makes total sense and then just kind of riffing a minute.
• 10:17
  [SPEAKER_00]: That's been my whole thing with AI since the beginning.
• 10:20
  [SPEAKER_00]: It's like, how can you build or how can you build on top of something that's probabilistic?
• 10:23
  [SPEAKER_00]: You can't trust that it's going to come out 100% right all the time.
• 10:28
  [SPEAKER_00]: I really like how you've structured this this approach here.
• 10:32
  [SPEAKER_00]: I'm curious about you mentioned pre-range coding and some of our emails we exchanged and I really like that term.
• 10:38
  [SPEAKER_00]: What does it mean?
• 10:41
  [SPEAKER_01]: I came up with that, that's when I started experimenting and building gainable and trying to understand how is lovable and replete and bold whatever designed and what does it do with a prompt.
• 10:54
  [SPEAKER_01]: And then when I look at it, obviously like anyone else, I just throw prompts at it and then you can look at the code afterwards.
• 11:00
  [SPEAKER_01]: and it literally are using technology that is designed for teams and not singular and it's designed for seniors and not juniors and so forth.
• 11:11
  [SPEAKER_01]: So it's designed like the engineers that build it basically tell LM, go crazy, use whatever you want, use it however you want.
• 11:20
  [SPEAKER_01]: And since the LM is trained on React because there's a lot of information about React
• 11:24
  [SPEAKER_01]: It's trained on tailwind for example.
• 11:26
  [SPEAKER_01]: It will pick those pieces because that's what it knows best based on the prompt, right?
• 11:29
  [SPEAKER_01]: That is what I mean with the free range coding.
• 11:32
  [SPEAKER_01]: The problem that is like react is definitely not the best way, maybe to build a simple app because it's very it's like a thousand dependencies for a button.
• 11:41
  [SPEAKER_01]: And it's just like we act was created for an engineering team to be able to work like back in front of them and having small pieces together or working on small pieces separately.
• 11:52
  [SPEAKER_01]: But an agent wants to look at one line of code and figure out what is going on here.
• 11:56
  [SPEAKER_01]: So that's like, I thought it was just doing wrong choices.
• 12:00
  [SPEAKER_01]: And that is, if you're throwing them again, we come back to the word probabilistic, right?
• 12:05
  [SPEAKER_01]: The more it can choose from, the more wrongs it's going to do in my opinion.
• 12:10
  [SPEAKER_01]: It's going to be more errors by error-pronged because it can make a lot of choices.
• 12:14
  [SPEAKER_01]: And LLMs are also designed to be helpful, right?
• 12:17
  [SPEAKER_01]: I would argue that an open AI model or chat-tpt is more friendly and more eager to help then cloud in a good way because cloud is following instructions while opening AI is saying,
• 12:30
  [SPEAKER_01]: But that's what I mean like basically going bananas and using all the coolest things because it's in the base point as well.
• 12:36
  [SPEAKER_01]: Not necessarily what is good for the potential output in the end.
• 12:40
  [SPEAKER_00]: Good stuff.
• 12:41
  [SPEAKER_00]: This is really interesting.
• 12:42
  [SPEAKER_00]: Okay, let's move into another topic around AI in general.
• 12:46
  [SPEAKER_00]: That's tokens, right?
• 12:47
  [SPEAKER_00]: You pointed out to me that they still appear to be heavily subsidized.
• 12:51
  [SPEAKER_00]: What do you mean by that?
• 12:52
  [SPEAKER_00]: Don't mean the audience, what do you mean by that?
• 12:53
  [SPEAKER_00]: And what happens to AI products when the subsidized
• 12:59
  [SPEAKER_01]: It's been a while since OpenAI did like a messy round, but in that, at least some of the public information that can access this, you can see how much time, how much money they're burning to generate like a token, basically, and it's way more than your charging, but it's a race, I would almost say a race to the bottom in terms of finding the clients and building habits, or I won't use OpenAI, I won't use Cloud or.
• 13:22
  [SPEAKER_01]: I want to use crock or whatever.
• 13:23
  [SPEAKER_01]: So they need to subsidize the tokens because it's very expensive obviously because of the TPUs and the data centers and all the powers I needed.
• 13:30
  [SPEAKER_01]: And if you follow that line, for example, without open AI around, they did a while ago.
• 13:35
  [SPEAKER_01]: If you follow that line in terms of how much their revenue is amazing, but if you look at a hammer today, I should burn.
• 13:41
  [SPEAKER_01]: They would basically go bankrupt like in 24 months.
• 13:44
  [SPEAKER_01]: So right now it's again my kind of opinion is like it's creating habits and creating a following around a specific model because you like that more than the other one to the point you are like addicted to it in a sense, right?
• 13:58
  [SPEAKER_01]: And so at some point always companies need to switch over to okay now we actually have to make at least a small margin on every token generated.
• 14:07
  [SPEAKER_01]: But that's small margin on every token generated is very much more expensive when it is today towards a client or towards a user.
• 14:15
  [SPEAKER_01]: And the user is still thinking it's too expensive.
• 14:18
  [SPEAKER_01]: And Claude and I've already updated a completely different approach from getcode in terms of subscriptions, right?
• 14:22
  [SPEAKER_01]: So if you're using Claude code, you can have a pro, you can have a pro max and you can do 20x and whatnot.
• 14:29
  [SPEAKER_01]: Obviously, they're limited by your context window, but you can basically use it all you can eat.
• 14:34
  [SPEAKER_01]: But now with Fable 5, for example, they are turning that off as well.
• 14:38
  [SPEAKER_01]: You have to switch over to credits.
• 14:40
  [SPEAKER_01]: They still are giving it away under the subscription model.
• 14:43
  [SPEAKER_01]: But it's going to go over to credits at some point.
• 14:45
  [SPEAKER_01]: I don't remember exactly the date because they keep moving it.
• 14:48
  [SPEAKER_01]: But that is because it's too expensive to drive a sound business on top of the tokens.
• 14:57
  [SPEAKER_00]: Makes sense.
• 14:57
  [SPEAKER_00]: Okay, you mentioned Fable 5.
• 14:59
  [SPEAKER_00]: I'd like to dig in that a little bit.
• 15:01
  [SPEAKER_00]: I got switched off by the government for a while.
• 15:03
  [SPEAKER_00]: Everybody saw the headlines.
• 15:05
  [SPEAKER_00]: It was a crazy moment to be like, what's going on?
• 15:07
  [SPEAKER_00]: Why do you see this as a turning point?
• 15:09
  [SPEAKER_00]: Not a footnote.
• 15:10
  [SPEAKER_00]: I can't it?
• 15:10
  [SPEAKER_00]: I think it connects with what you're just describing.
• 15:12
  [SPEAKER_01]: Yeah, like that whole debacle is like you haven't sent to the open models like GLM, Minimax and Kwan and whatnot.
• 15:22
  [SPEAKER_01]: Well, shit, I cannot depend maybe on these frontier models, because now it's becoming politicalized as well.
• 15:30
  [SPEAKER_01]: there is obviously someone who can just switch it off and if it was not turned off because it stopped working right there was turned off because someone decided it should be and that would decided it to be turned off was not the company they got like subpoena or whatever they got okay if you continue to do this you're going to be in trouble and that part is new and that also like puts time from Europe so that's basically our feet to the fire and turns okay
• 15:54
  [SPEAKER_01]: There is not a European model we can lean on, like you see either China or US, so that shows the vulnerability of the whole industry.
• 16:02
  [SPEAKER_01]: So it's definitely not a footnote.
• 16:04
  [SPEAKER_01]: It's like a big shift.
• 16:06
  [SPEAKER_01]: The crazy thing, like how we open-fable five was to prove that Dumber or less capable models could do the same thing as fable five, right?
• 16:15
  [SPEAKER_01]: And how does that make sense?
• 16:17
  [SPEAKER_01]: I mean,
• 16:18
  [SPEAKER_01]: The government and the US should then say, okay, you should shut on all the models.
• 16:22
  [SPEAKER_01]: That would be the logic after math, but they couldn't because obviously that would be too crazy.
• 16:27
  [SPEAKER_01]: So who knows what's going to happen in the future with that?
• 16:30
  [SPEAKER_01]: But it's definitely making people, I think, in my industry to think twice and look at, okay, either actually create your models or lean in way more heavy in open models.
• 16:41
  [SPEAKER_00]: That makes sense because it's the model and you've touched on this a bit and our conversations The model is a commodity everyone rants.
• 16:48
  [SPEAKER_00]: Where's the mode?
• 16:48
  [SPEAKER_00]: What keeps people staying on certain models?
• 16:51
  [SPEAKER_00]: Right?
• 16:51
  [SPEAKER_00]: What keeps people actually using a certain piece of technology if there's no If it's something everyone just rants can you touch on that a bit?
• 16:59
  [SPEAKER_01]: Back to, for example, my opinion about, for example, lovable, it's very much just a wrapper on top of whatever the model they're using and you can switch easy between open AI and public and so on and so forth.
• 17:11
  [SPEAKER_01]: But that means the mode is the factory in a sense, right?
• 17:16
  [SPEAKER_01]: So, I talk a lot about lovable here, but lovable's modes, I would say, it's now, they were first mover created, it's very strong community and like a good brand and people know about it.
• 17:29
  [SPEAKER_01]: But it's not the end, you know, where everyone is renting the same model by the end of the day.
• 17:33
  [SPEAKER_01]: So what, like we've seen it happen already, it didn't disrupt maybe the whole business operations.
• 17:40
  [SPEAKER_01]: But figma make and then all of a sudden, clawed the sign.
• 17:44
  [SPEAKER_01]: Then the supplier of an AI frontier model that figma make is definitely using.
• 17:51
  [SPEAKER_01]: All of a sudden, that supply decides, okay, I'm going to create something that is similar to what you already do it.
• 17:56
  [SPEAKER_01]: You can just imagine or play with the thought that you will have quote-to-quote the lovable experience by Claude tomorrow, that would be bad news, right, for the whole love by-coating industry.
• 18:07
  [SPEAKER_01]: Because the end user doesn't care if lovable is using Claude or OpenAI.
• 18:14
  [SPEAKER_01]: They care about natural language, building something looks good in the other end.
• 18:20
  [SPEAKER_01]: This whole thing, like switching models, doesn't really matter for the end user.
• 18:23
  [SPEAKER_01]: But then if Cloud says that we're going to do a competitor for half the price, then that user will move in five seconds from lovable to Cloud.
• 18:33
  [SPEAKER_01]: Because you will get the same output for half the price for example.
• 18:36
  [SPEAKER_01]: So that means like you definitely don't have any defensibility against that because you don't own them all the engine I'm using got ripped away and now whatever I have I just have a chassis to my car but the engine is gone because
• 18:51
  [SPEAKER_01]: the credo at the end you create a new core and now I'm not used to it or whatever like it's just very interesting right and also I would say some conspiracy theorists like but people say okay Claude and I'm from because training themselves on things that works and then they're going to create a vertical that's going to compete.
• 19:07
  [SPEAKER_01]: Legora, a Swedish company doing AI4 law firms and Claude recently launched Claude Legal.
• 19:15
  [SPEAKER_01]: which is basically competing with them.
• 19:17
  [SPEAKER_01]: Did they train only Gorah stuff?
• 19:20
  [SPEAKER_01]: Question mark?
• 19:21
  [SPEAKER_01]: Some people claim.
• 19:22
  [SPEAKER_01]: So what are these proprietary frontier models actually doing behind the scenes?
• 19:26
  [SPEAKER_01]: And the back of the saw, was it today yesterday or something where it came out a grock when using grock.
• 19:33
  [SPEAKER_01]: It just takes a cold copy and clone your whole repo and uploads it's own cloud without telling the user.
• 19:39
  [SPEAKER_01]: and so on and so forth, right?
• 19:40
  [SPEAKER_01]: In the reason is this, we keep on forgetting how old is this industry.
• 19:45
  [SPEAKER_01]: We're talking what?
• 19:46
  [SPEAKER_01]: 12, 14, 16 months.
• 19:47
  [SPEAKER_01]: Like you and I have been in the IT industry forever.
• 19:50
  [SPEAKER_01]: It's never moved as fast as now.
• 19:52
  [SPEAKER_01]: So obviously business model is going to break.
• 19:53
  [SPEAKER_01]: The usage is going to be like how you use it, it's going to break and things are going to shift and it's going to be very optimistic.
• 19:59
  [SPEAKER_00]: Yeah, no, no doubt.
• 20:01
  [SPEAKER_00]: Okay, required to get one more question and it's a general one.
• 20:04
  [SPEAKER_00]: I'm curious.
• 20:05
  [SPEAKER_00]: Where are you taking gainable next?
• 20:06
  [SPEAKER_00]: What is next for gainable?
• 20:08
  [SPEAKER_00]: And how can someone join and get started using the platform?
• 20:11
  [SPEAKER_01]: Next step is actually we're going to launch our own mobile on that topic.
• 20:15
  [SPEAKER_01]: It's very interesting in terms of how you can, whoever's listening to this is or into AI in based prompts and instructions about them.
• 20:24
  [SPEAKER_01]: When you do your own model and you find you, and if you can basically remove your whole system prompt, that tells it to specifically do, and then focus only on the output, what you wanted to create because it doesn't have to think about, you don't have to force it to do things because the base model is not trained for it.
• 20:41
  [SPEAKER_01]: And that part, you think, is very interesting.
• 20:43
  [SPEAKER_01]: So that is like one big piece.
• 20:45
  [SPEAKER_01]: And that is also because, as I said, we are focusing on channel tooling.
• 20:49
  [SPEAKER_01]: That means we are selling to enterprises, big companies.
• 20:52
  [SPEAKER_01]: In the past, I've been selling to companies like NATO, or Chatelecom, Chab, you name it like big IBM and so on.
• 20:59
  [SPEAKER_01]: One very important thing for these companies to be able to run its air gap behind the fire wall in a private cloud, even on premise.
• 21:06
  [SPEAKER_01]: and gainable is designed to be totally deployed internally behind every firewall, including LLM.
• 21:13
  [SPEAKER_01]: So that's what our own model is going to provide us to be able to do that.
• 21:17
  [SPEAKER_01]: And I think that is a major step forward in terms of, because the whole life, I can build internal apps using the level right, but it's not sustainable.
• 21:25
  [SPEAKER_01]: It's not sustainable for a company to do that for many reasons.
• 21:29
  [SPEAKER_01]: And it's not to sign for it.
• 21:30
  [SPEAKER_01]: You can probably not just containerized, lovable, and then plunk it into some usage in an idea cutoff office.
• 21:37
  [SPEAKER_01]: I'm pretty sure you can't do that.
• 21:39
  [SPEAKER_01]: So that is what's on our horizon, and I'm focused now, and it's really fun.
• 21:41
  [SPEAKER_01]: We're doing actually pretty close to Nvidia.
• 21:44
  [SPEAKER_01]: We're doing like we're using their NEMOTRON open model.
• 21:48
  [SPEAKER_01]: So we're part of their inception program.
• 21:49
  [SPEAKER_01]: So we're creating the model on top of that, and that's super fun and interesting in my opinion.
• 21:53
  [SPEAKER_01]: And if you want to try gainable, you just go to gainable.dev and you ask guide, which is our agent, take my Excel sheet and create an application for me so I can invite my team and then six minutes later we will have an application that you can invite your team to and then you can refine and play and so forth.
• 22:10
  [SPEAKER_00]: But
• 22:11
  [SPEAKER_01]: And you can also see it like coming back to the tokens, like we do not have credits, we don't have tokens.
• 22:16
  [SPEAKER_01]: We have flat pricing because of our compiler.
• 22:19
  [SPEAKER_01]: I pay in the back end between $1.50 to build a complete app from end to end with tokens.
• 22:26
  [SPEAKER_01]: Because the compiler is the key at the core to build the big pieces of speaks.
• 22:30
  [SPEAKER_01]: The output tokens is very low for us.
• 22:33
  [SPEAKER_01]: Oh, that was a very long answer to you, Crescent.
• 22:34
  [SPEAKER_00]: But yeah, that's what I'm looking at like next steps for gainable.
• 22:39
  [SPEAKER_00]: That's a fantastic answer.
• 22:40
  [SPEAKER_00]: The next steps are exciting and it's a really cool approach.
• 22:43
  [SPEAKER_00]: You're taking to using AI to build applications based on data in a more effective way, not just more effective but deterministic.
• 22:51
  [SPEAKER_00]: And again, I mentioned earlier, like, that's been my big beef with AI since the beginning.
• 22:56
  [SPEAKER_00]: It sounds like you're trying to solve the problem and get people the direct access to applications they need based on the data they have.
• 23:03
  [SPEAKER_00]: Without having to bring in engineers without building something on top of a specific model that's out there and using AI to build the specs to feed into your compiler to build something deterministically.
• 23:14
  [SPEAKER_00]: It's a really fascinating approach.
• 23:16
  [SPEAKER_00]: I really appreciate you coming back on the show and telling the audience all about gainable.
• 23:20
  [SPEAKER_00]: We'll be sure to link it in the show notes, but thanks again.
• 23:22
  [SPEAKER_00]: Thank you, thank you.
• 23:25
  [SPEAKER_00]: Recart is taking a fascinating and brilliant approach to building a deterministic app generator, not based on prompts to AI, but based on data, AI, spec building, and a compiler itself.
• 23:38
  [SPEAKER_00]: We hope you enjoyed today's episode.
• 23:40
  [SPEAKER_00]: If you'd like to check out gainable, go to gainable.dev.
• 23:44
  [SPEAKER_00]: That's G-A-I-N-A-B-L-E.dev.
• 23:49
  [SPEAKER_00]: And thanks again for listening.