build in public #1 - project showcase

This is my very first, building public blog.

But I wanted to go away from just very well researched blog articles because I'm not a pundit, I'm a builder.

So I want to show you what I'm building because if I did this, I would have a lot more content.

And I'm pretty sure that you guys are more interested in this one.

So today I want to talk about four things.

things.

Alfred, Dovetail, Joe and Jake Offred is the project that you guys know about.

Dovetail is a new project that I teased in my latest blog article, which helps me be not just more productive, but also be a better engineer without having to be a better engineer.

And then Joe and Jig are client projects, which I'm going to talk about just a few minutes.

And then there are a couple other fun stuff that I'm going to show you.

So, Alfred.

I started working on Alfred, last August, right when I said I'm building my own butler.

Because basically what I wanted, And everybody was promising that with AI, but it's not doing that.

And it's pretty annoying because of hallucinations.

And I And then even a couple months later, MCP1 was introduced in November and I'm like, yeah, that's what we need.

But even that is very brittle.

So anyway, I started building N8N workflows, because that's actually easier than coding.

At least that's what I thought.

And then basically I figured, hey, I want Alfred to just run these N8N workflows for me and build these N8N workflows for Me.

And then really quickly I realized that a big problem of this is connection.

Like having MCP connection and then not paying a shit ton ofmoney to make.com or Zapier or N8N.

So I need self hosting.

And then I went into this whole self hosting idea.

So I started building on Alfred os, which was supposed to a bunch of open source applications for you and just run a bunch of apps, but the open source alternatives for that.

So like instead of make.com let's use N810 because you can self host it.

Instead of Zoom, Jitsi because it's the same thing but open source.

And then I would have skills for authors, N8N workflows that can really do stuff well.

And then, you know, if I want to use MCP servers, I can just add them to skills.

But the point is that an Alfred skill would be deterministic, right?

That's the big problem that I've had, because you go into Claude and you create a bunch of connectors, and then it starts doing stuff with the MCP servers, but then it starts hallucinating, and I need someone to hold the agent's hand to not drift off.

Because the moment it starts working with lots of data points, it starts to drift off.

And what happens if I'm like, hey, get me data from this, from this, from this, from this, and then prepare a report for me.

And then it's just so much bloat and data that it drifts off.

So that was one big problem.

And the second big problem was that, I'm shit at DevOps, so I needed to figure this out somehow.

And I ended up creating a railway template which is, you click once and it deploys a bunch of apps, like n8n and nocodb and cal.com.

some of them work, some of them don't.

And then it also deploys a custom version of LibreChat, which is just a ChatGPT clone that would allow you to use your own API keys to have a chat with Alfred.

And then inside Alfred, Alfred would be connected to all the apps that you had.

And I'm like, yeah, that's pretty cool.

But I still want the N8N workflows to be running automatically.

And for that, I would want it to be hosted locally because I want the hosting part to be done, so I'm not paying for the cloud version.

and then the N8N licensing issue was a big problem because that I cannot do unless I pay up, 50 grand a year.

And I don't want to.

So I was kind of stuck, right?

I wanted Alfred to just know things and do things and save money.

And then the ultimate idea was that I would have this And then, boom, it installs the whole Alfred OS and the agent and the skills and everything on a server, and then Alfred can do stuff for you.

Now, the problem is, even if I solve that problem, I still cannot work with an 810 because I don't have the embed license.

So instead of doing that, I needed to figure out some other ways.

And there are a couple other ways.

Like, for example, what's really Promising is Manuscript now has a thing.

It has an API, right?

I don't even know where the API key is.

Or maybe here.

So Manus has an API, which means that I can just give tasks to Manus, but the problem still remains.

It's like, okay, I don't have to do the N8N thing.

I can still probably figure out how to build the cloud bit, but I never done that before.

But even then, this is not really going to be entirely free because you still need to pay for credits.

So I decided to kind of streamline the whole thing.

What I'm showing you is something that I built in the last three days, and this is how powerful my new workflow has become.

is that I was able to solve a problem that I don't have the skills for in three days.

So the idea of Alfred is basically, it's an execution layer for AI, You get an MCP server, you connect it to Claude or ChatGPT or whatever, and then it just knows things, does things, and saves money for you, and that's it.

And how it works, it is technical, but your experience of it is not technical.

So there's a big problem with AI execution, which is these things are very smart, but they're not logical.

They cannot employ actual reasoning, which means that reasoning unlocks deterministic workflows.

I tell you to follow step 1, 2, 3, 4, in this order.

And the AI may or may not do that.

There is no validation, there's no enforcement, there's no deterministic stuff.

For that, you need to write code, and that's kind of the plumbing that's missing.

So basically we would need separation of concerns.

We want the agentic work, which is flexible and scalable, but also can hallucinate and be unreliable.

But it's really good with unstructured information.

And that unstructured information is the idea I have in my head.

but once it's clear enough, I want the AI to kind of lock it down.

It's like, hey, here's the deterministic way of getting things done, and here's how I'm going to do it again and again and again.

Claude skills are a good move in that direction, right?

There are agent skills inside claude, but these are just mega prompts and short scripts, and it's not entirely what I would want.

So it's like, okay, we're getting there, but the flow I'm expecting is.

And the original flow I was expecting is, I talk to Alfred via chat.

And then once I figure out what I want, alfred builds an N8N workflow for me.

And then I can set when it should run where I can just say, hey, Alfred, run this for me.

And that would turn Offroad into an operator like a chief of staff, but AI, and it doesn't work because all the N8N workflows Claude or any other AI tools can build are not very good right now.

And it's just brittle.

So we need something better.

And the MCP was an idea that, you know, MCP servers and I just give the tasks to Alfred, to Claude, and then it just calls the MCP tools.

But it's, it's, then it's unreliable and hallucinates.

So I either have spaghetti inside N8N that I need to plumb, or I use an agent that tries to kind of cosplay as Dexter from Dexter's laboratory, but really it's dd and that's the big problem.

So in order to solve that, I came up with two things called talk mode and work mode and the version of all three that I'm building right now.

Basically what you get is that the moment you log in, what happens, is you get deployed, you get provisioned a new server.

So let me show you.

This is the current version.

It's, it's very early stages, but I'm using the open SaaS template.

It's running on a WASP framework and I definitely recommend you take a look at it if you want to build apps, because it's complete stuff, stripe integration, authentication, everything.

So when you're in Alfred, it's, you know, the namings and everything are not, done yet.

It's all running locally.

But the idea was I log in and then when I log in, I would just click on launch my Alfred os and then it starts getting created.

And then when it gets created, it's pending, which means that, there is a server that's currently setting things up for me, currently using Contabo, because I'm going through the verification process with Hetzner, which I don't know, I've built.

I've opened bank accounts with less but if you look at it now it's provisioning.

And now I got a, specific URL DynamicPheasant Alfredos site.

This is set, the DNS configuration is set, but you also get the IP address.

Now currently nothing's installed in it, but now there is an automatically generated virtual machine that I can, that sets itself up and Then with a setup script, and then inside that setup script I can add whatever app I want to add.

So that's the next step.

So I solved this problem.

And we're getting pretty close to the Alfred cloud because the big change is that I let go of the idea of installing N8N on this.

okay, so once you have that installed, you will have basically two apps that comes with the install, LibreChat and NoCODB.

And that's very intentional because you're not probably never going to have to open that.

What you're going to have as a quick start, you're going to get a simple URL and an API key and all you need to do is go to Claude or ChatGPT and add Alfred as a connector.

And once you add Alfred as a connector, then you can open Cloud and say, hey, Alfred, do this and do that.

And it will actually use Alfred instead of Claude.

Like Claude turns into Alfred for that session.

this is the chat part.

If you want to go to Libre Chat because you don't want to use Claude, you can still open the Libre chat.

That's why it's there.

can open Libre Chat and use Alfred there.

It will have the MCP connections to NoCODB.

It will have all the MCP connections you want to, and then the Alfred MCP will do the same thing that LibreChat can do.

So there is the same thing, but the use case here is not that.

And that was my biggest pet peeve is that I was getting distracted with the Alfred os.

This is just an infrastructure thing.

And now that I figured out how to run this, I will just create Alfred Cloud where you pay, I don't know, probably $40 or something per month.

And then you get a server, full access to it if you want.

You get a server and then it runs Alfred, it runs all the apps, it runs LibreChat, and then you have your own little thing and all the data is yours.

but the interesting thing is happening inside work mode because the idea that I want, I have is that I want to teach, offer the skill once and then I want Alfred to just remember how to run it forever.

So I would just describe something like, hey, process my emails and organize them into labels by topic of any importance.

And then I want Alfred to automatically look at my connections and see what's what, get the context on my little word, my reality, and then come up with an idea of how this should actually work.

And then it comes up with a solution.

It's like, hey, I think what we should do is connect to Gmail and then fetch unredeem us from the last 24 hours, etc, etc and then also give me a couple extra ideas like hey, what if we do a sentiment analysis from another MCP server as step 4?

Or what if I do this and that and then you say, okay, you know what I want you to do option C.

And then I just say learn it.

And then when I say learn it, then Alfred, it doesn't save the skill into memory.

It actually creates deterministic code that will trigger Alfred running every time, the exact same time, the exact same way, the exact same tools are being used.

It's deterministic and reliable and does the exact same thing all the time, much like in any 10 workflow, but you just built it in four steps because you let Alfred do the heavy lifting for you.

So talk mode and work mode is really just separation of concerns, right?

Talk mode is about authoring.

It's like ad hoc conversations, exploration, hey Alfred, do this, do that.

And then whenever something happens it's like, hey, what we just did, just give me a, like a few step walkthrough of what you did and what tools you used.

And then when Alfred gives you something like, oh, this is a really good workflow, I want to learn it.

And, and I want you to run it every Monday at 7:00am and then Alfred actually transforms that into a skill and that replaces an N8N workflow.

and that's it.

Inside work mode, you will have a trigger, you will have the actual skill which have the actual steps.

And then Alfred always runs it, completely deterministically all the time.

And then the idea here is that, you know, clothes skills are supposed to kind of do that, but the authoring bit is missing and the orchestration bit is missing, the execution layer is missing.

So let me give you a couple examples.

Let's say I just type in hey, every Monday I want you to pull revenue from stripe support tickets, project updates, Slack mentions, and then send me a summary on Slack.

And then Alfred understands what I want and then it creates a workflow suggestion.

And then it's not like a 45 node spaghetti, it's really just six steps, right?

Because it's like agentic in execution, but deterministic in orchestration.

And then once I say, yeah, that's it, learn it, then it saves it for itself and it will do those steps exactly the same thing or another thing like, hey, Alfred, I want you to analyze, support my Support tickets, find buying motives, build our ICP research leads in Apollo and then save them into my database.

Like this is a pretty big work.

So I'm like okay, let's see, let's we trigger this manually and pull support tickets via Zendesk.

Then I'm going to analyze it says via Alfred os, which means that Alfred is thinking instead of using external tools.

So analyze buying motives, build icp.

Then based on that I'm going to use the Apollo MCP to research matching leads and then save them to the database.

And then I can also do stuff like self maintenance, right?

I can just say Alfred, I want you to every Monday I want you to analyze our conversations from the last week and suggest me skills to add or remove or improve.

And because Alfred can examine itself, it will pull conversation from the history from last week using its own mcp.

Then analyze skill usage patterns, identify gaps, generate improvement suggestions and then send your report via Slack.

And then Alfred might suggest to relearn some skills if there are some errors or something.

So you don't need to deal with any of that.

another example which is something that I started working on is I have a home Assistant here at home and I started connecting everything.

And then there is the Home Assistant preview edition, which is basically like Alexa but for Home Assistant.

And then you can run anything on it.

So I have a Home Assistant voice preview.

It's downstairs in the kitchen.

It's connected to chat, it's connected to OpenAI.

I think it's using GPT5 and it also has the iconic Alfred voice from elevenlabs and that's it.

So then I have cameras, I have smart switches and stuff.

So what I can do is I can say hey, if someone's at the door and I don't reply on Slack in 60 seconds, call my phone.

So then Alfred is like, okay, first I need to have a workflow created.

Trigger would be a doorbell event.

I need to figure out what that is.

I just connect to Home Assistant through an MCP connection and find that event.

And then I will just okay, that's the web hook that I need to set.

So you don't need to deal with any of that.

And then it's like, okay, step one, detector doorbell rings and Slack alert.

Wait 60 seconds, no response.

If it replies then you know, I can see that on Slack.

So I don't do anything.

If no reply, then I'm going to initiate a phone call which can be either via Twilio or it even can be using vapi, which, you know, just have a voice agent.

So Alfred can actually call me and say david, someone's at the door.

Like go check it out.

You're not looking at Slack right now.

So the idea here is that this is the kind of stuff that I want to use and it's pretty annoying to me that I can use clothing, skills and everything, but it's not doing the stuff that I would want to do because it's hallucinating.

Or I can build any 10 workflows which are again not doing what I want because they're so complicated and spaghetti and they're brittle and fragile and unreliable.

So the idea here is that Alfred will come together as everything, right?

You just click on deploy once like you did it here.

If I you can see it's running.

It got an IP address, it got a host and that's it and everything's there.

So login, sign up for Alfred, then you get an MCP server and API key so you can start immediately using it.

And then Alfred OS gets deployed into that server for you.

So Alfred has instant connection to open source tools and then you will have apps that you like.

Open source apps.

I'm probably going to build or add more apps to the App Store.

or you can also add your own MCP connections.

Like let's say you love Zoom, you don't want to use Jitsi.

So instead of installing Jitsi on Alfred os, you're going to just create an MCP connection for Zoom to Alfred and from that moment onwards Alfred understands what's about I'm probably going to have, for the Alfred cloud, we're going to have a solo version which is going to build the lowest tier and that's going to be you know, including the whole thing, very basic Libre Chat and NoCODB.

And then whenever there is new apps coming up in the App Store you immediately get access to them but you can start using offered immediately.

I'm not entirely sure about the pricing.

It may be, I don't know, it may be usage based or like skill runs or it may be a, simple monthly fee.

the Alfredos bit is just, you know, it's flat, it's, you have full root access to the server, and on top of that you have Alfred as the agent.

the way the Alfred OS gets deployed I'm still going to make that open source.

So if you don't want to use Alfred as the agent, just want to self host stuff.

You will get access to that.

then also thinking about another tier.

I'm not entirely sure how this would work.

I may just have the offerage solo and that's it.

And then you know you can add as many MCP connections as you want.

But the whole point is you know, collaboration and skills library because the real value is going to be in skills.

And then for those who have existing businesses and they're like hey, I have a bunch of automation that I need here.

I have the offered pro subscription which would come with a white glove onboarding and I will come on board and help you create the skills, help you set everything up for yourself.

And then you just get a URL to log in and you also get the Alfred mcp, set up as a one pager and then you know we would monitor the skills and the skill development.

So you really get sort of a performance supervisor for your Alfred AI Chief of staff.

I don't know about pricing yet.

I'm still thinking about it.

There's a lot of stuff to do.

I just want this to work first.

And finally sort of clicked everything together and it works and the skill gaps are closed.

So yeah, I'm going to launch this website soon and and, and probably give some more updates but also because I don't want to just you know, show you and talk to you about theoretical stuff.

I have started using Linear for tracking my work and inside Linear I have a bunch of projects.

Some of them are, you know, client projects, some of them are my own projects.

And here is Alfred, which connects to my project, management tool, again Linear, and it has all the stuff that I'm working.

So full building public mode.

Right?

Full building public mode.

You can see all the stuff that I'm working on.

you're going to see how these are created.

I'm building everything with cloud code, so this is public.

And I'm going to share the links to the different roadmaps to the different products I have below.

And you will have the ability to keep track of things and ask questions and whatnot.

So again I want to build fully in public.

yeah, so this is Alfred and probably the first question most people are going to ask is when is this going to be ready?

honestly I don't know.

I keep building it and now I feel like it's probably going to be closer than I Figured, there are a couple people who paid for the original Alfred and I will give them the option to either have for the Alfred cloud, or use it for sort of a white glove onboarding session.

and then, you know, keep them on.

So I don't know, we'll figure things out.

A couple months ago I suggested that if you paid for it, you can just ping me and I will help you set it up for yourself however you want.

That still stands.

Okay.

So I'm going to keep posting about what I do.

The first video is like pretty blunk.

But I'm going to start releasing more updates to you on YouTube and here on, on the Lumberjack.

And it's just, you know, immediate stress.

Hey, here's what I'm building, here's where I'm at.

So you will be able to see that.

Now how and why can I do this?

So then we get to Dovetail.

Dovetail is a really interesting project because first, here's the evolution, right?

I started with IFTTT in 2014.

That was the first time I built a no code automation.

And it was, I think it was archiving photos from my iPhone to Dropbox.

And back then I was running a software company.

I was designing and launching products and I was raising VC funds and doing stuff.

And, and I did a lot of technical stuff in my life, but I never really coded.

So this whole no code idea was pretty cool.

And then as you know, life happened and the AI thing came and then there was the promaster, era where I really got into make.

So in make.com, i started using it in 2023 and I got really, really big on that.

But the problem was it got really expensive really quickly.

So in 2024 I moved over to.

And the interesting thing about here is that these are progressively more and more complicated.

Somewhere in between these two I was using Zapier, but that's like super expensive.

So with NA10 it wasn't enough.

So I had had to add Jetbrains, which was not Jetbrains.

Sorry, let me check for.

Check it.

So I, joined.

I started.

So I started using Jet Admin for creating a ui.

And then there are a couple solutions like that, like Bubble and Softer and Framer and a couple other stuff.

So I was looking around and then I started getting into using Airtable a bit more and then I moved over to Supabase.

So you know, my stack started expanding, getting more complicated as I was building more and more complicated stacks stuff.

And then, in 2025 I started using lovable.

And basically lovable plus Supabase, replaced everything else.

So I didn't need to use any 10.

I could just create Supabase Edge functions.

I didn't need to use Jet Admin because Lovable was building the ui.

I didn't need to use Airtable because Lovable had a native Supabase integration.

I felt powerful.

It was really good.

But then the problem is the same thing that we discussed with the Alfred problem, which is it's brittle.

Even Lovable UI gets really, really, complex and brittle very quickly.

So it wasn't very reliable.

So I started focusing more and more on dev work.

I was learning a lot of stuff.

and then ultimately I ended up using a lot, right?

So with Cloth Code, I tried Warp, I tried Cursor, I even used Cloth Code in the Simple Terminal or powershell, and you know, it works perfectly.

It's fine.

So cloud code is pretty cool.

And then I started going through like a productivity boom, right?

So then I went into Cloud Flow, which, is built by Riven Khan, and it basically launches a bunch of cloth, code instances.

And then you just, you know, have an agent swarm that builds stuff for you.

And I don't know, man, it's it got, it got overwhelming really quickly because the hallucinations problem was still there, right?

So Cloth Code was really great, but, it was still hallucinating and making stuff up.

Cloth Flow is the same.

I love it.

It's pretty cool.

But there is a lot of it that's just smoke and mirrors.

There's a lot of, you know, I don't know.

There's a lot of parlor tricks in there, I think.

so after a while I realized that basically, I have the same stack every time I work, right?

Almost all of my projects are almost always built on the same stack.

I use Supabase for db.

I, use Supabase for authentication.

I use Supabase for serverless functions, and for APIs as well.

It just gives you, like, you create a project in Supabase and then you're done.

I started using Linear for documentation and project management.

Because I wasn't doing anything correctly.

So I had to start forcing myself to start documenting stuff.

And then I started, using Fly IO for hosting.

It's pretty cool.

It's pretty lightweight, pretty thin.

And you just, create an app on Fly IO, deploy it and runs it and kud, code can deal with it pretty easily.

So I'm like Supabase Linear Fly IO.

And then I was still using Lovable for ui, but then immediately, once I have the UI more or less nailed down, I will move it to GitHub and then the GitHub repo into Claude code and keep working from there.

But again, there were a couple problems, namely around code changes and commits, comments and auditability, etc.

So the big problem I had with this is that I just kept working and working and then in the beginning I was looking at the stuff that cloth code was changing.

But then after a while I got complacent and then, you know, it started replacing entire working features with placeholders for no particular reason.

So I needed to learn a bit more about branches and pull requests and everything in GitHub.

But then all of a sudden I had this whole idea that, okay, so I have an idea.

I go to claude code and I say, hey, do this and change that.

And then claude code out of context, it just pulls stuff from its memory and then it starts building something and then it pushes it to GitHub, which then pushes stuff to fly IO and it gets deployed.

And then if it deleted something from the database, like I need to go back, but I don't actually realize it until like an hour later.

So in order to make this work, I needed to have a pretty strict flow, right?

I needed to.

First of all, when I start working on a project, I don't want to deal with any of this shit because anything, everything needed to be connected.

So but let's say I have this set up, everything is set up.

So then what I do is I send the prompt.

Let's say I start, start cloud code code and then cloud code, code or me.

Somebody needed to check the git repo status, latest comments, latest latest updates in linear, connections, and basically get, get the context or get context on what's what, right?

And then I say okay, send the prompt on what to build.

But if I'm not doing it right, if, if it's manual, then inside the prompt in the prompt I would need to do stuff like check linear, check db, do this, do that.

And even then in order to like do everything properly, I would need to say check linear to see if my request is related to any issues issues.

Then check the Latest commits on GitHub to see if we worked, worked on this before.

Then figure out what I want, right?

And then if it figures out what I want instead of just starting to build it, I would need to say create a new or or move to a new branch in Git and start working on that.

Once done, create a pull request and update, Linear.

So if it's manual, then I do all of this before I send the prompt.

Or I could just say claude code does it, cloud code does it.

And then we could have skills which is automatically invoked or not.

So I don't have control over that.

That's not really good.

I can use a, claude CLAUDE MD prompt, which again works.

Or not.

So then we have the new Claude plugins, which was pretty cool.

You know, it kind of does what I want.

But I was like, okay, so Claude plugins are basically commands and hooks.

But what is the hook that we're running here?

Right?

how do we make it work?

so I had the idea of launching sub agents, but then again, it works or it doesn't because then the agent is doing the orchestration.

So anyway, so I decided that none of the current solutions solve this.

So I started working on Dove there.

And what Dovetail does is first off, I can just create, I say Dovetail init.

Let me show you.

So basically the way you install Dovetail is you say it's on npm.

So NPM install G numberjang.

So Dovetail and then you install it and then it pulls the package from npm, it pulls the code and then you can check the version and then this is the current version and you can take a look at all the different, all the different commands DAVTA currently has.

If it's the first time you're running, you can go to DAVTA onboard, or if it's not the first time, you can go to DAVTA Config.

And in the config you can see that there are a bunch of different, connections put together.

There is GitHub, the Lineari CLI and the Linear API.

Linear doesn't have a command line interface.

Supabase, connection Fly IO connection, and then also a couple of default stuff like what's the default organization, what's the linear team key was the Supabase default organization.

It just walks you through that, right?

And then that's it.

Now the interesting thing about all this is if something's not working, you can also just, launch dovetail.

Dr.

And that's it.

Now, if I want to create a new project from scratch, what I have to do is I just say Dovetail Init and then project name.

I'm not going to start it now because I just started, I just ran it before.

So it starts, let's say the project is Dovetail Live.

And then what happens?

It runs the authentication, right?

It asks me to confirm if this is the repository, do I want to make this public?

What's the linear, team key was the Fly IO region, et cetera.

And then it configures a project and then it creates the scaffolding.

So it creates a simple PERN stack application code.

Like the basics are set up, for running a, an app that can be hosted on Fly IO and whatever.

It's a container, you can build whatever you want in it.

Then it creates a GitHub repository, so creates a scaffolding, creates a GitHub repo, creates a linear project, creates a Supabase project, creates a Fly IO app, then installs all the dependencies, wire everything together, set everything up.

And then once, the whole thing is put together, the last step is it installs a bunch of hooks to clothe, right?

And then if I want to, I can go ahead and and take a look and see that.

Here is my scaffolded project that I just created.

I can go to Linear and see my linear project that was just created with a couple of basic issues.

or I can go to Supabase and I don't think this is going to load it because that's the project URL, but let me open it for you.

So I go to my project here And as you can see the Dovetail Live project, which ends with Xyle, as you can see, Xyle.

So this was just creating and created.

And then, if I go to Fly IO, you can see that there's Dovetail Live staging and Dovetail Live production.

It's still pending because it hasn't been committed yet.

Now I have this here and if I want to I can just go over to Dovetail, Live and then let's see what's what.

So I just go see the Dovetail Live.

Let's go back here.

There you go.

And I just can, I can just say Dovetail status.

And I can see we don't have an active issue.

So I can start running stuff here like Dovetail check issue and then it checks all the issues.

Are there any open?

No.

So I'm going to create a new one.

What's the issue title?

And let's say I want to create a DIY gardening landing page, no description, medium priority.

So here is the manual mode, right?

And it doesn't even work.

Right.

Okay, so what we can do is I just go to CD Dove there live and then what I can do is, you know, I can check Dovetail status status.

It shows no active issue.

So there are a couple stuff that I can do here, or if I don't want to do stuff manually, what I can do is I can just launch claude.

And then when I launch Claude, what actually happens is that because I installed a bunch of hooks, CLAUDE now automatically runs those hooks every time I want them to run.

So for example, every time a session starts up, there is a dovetail command that runs which gets us all the what's the project, what branch branch are we on?

What are the services, what are any issues?

Let's see what the commits are there.

what are the latest updates on Linear and and that's it.

Right?

And then no MCP servers are configured.

That's something that I will need to add to Dovetail.

So it automatically configures Linear MCP server and Supabase MCP server and everything for you so you don't have to deal with that.

But the idea here is that when I say build a DIY gardening blog landing page, then the idea is that before I actually send a new prompt, first let's say if there is an existing issue, there is none.

So the first hook fails.

So now it starts looking at the actual code inside the database, inside the code base, right?

And then it creates, it fills its own context, but it's not doing anything, it's not changing anything.

It's just learning about your, your code, it's learning about the environment it's in.

And it says this is a pern stack with a video and react, et cetera.

So now it understands what's up.

And then the idea is that all of these things, this is done automatically by a hook.

So the idea here is that Dovetail has a session start start Hook has a user prompt submit Hook has a pre tool use hook and a post tool use hook.

And that means that every time a session starts, check what's up with the project.

Get context on the last work when I send the prompt, double check if we are on an issue.

Is there an issue?

Is it the project?

Do we have anything like that?

And then before there is a pre session, look at this.

there is a pre to use hook that runs before it shows error, but it's not an error.

so it runs before write action is done and launches a Sub agent and that or sorry first checks if Are we trying to use a restricted tool?

Yes, the write tool, changing a file that's restricted.

So let's see what's the project was the main oops, no active issue.

So we're going to block block the task and instead we're going to launch a dovetail sync agent.

That's job is to say here's what the user wants, here is the project, here is everything about the project and then figure out do we need to create a new issue, do we need to create a new branch in GitHub, like what do we do?

And it just gets everything done for you together.

there is a current issue with the hooks.

That's what I'm working on right now.

it's not very stable at the moment so because I think the agents weren't installed for some reason.

But then the agent gets everything done for you and then creates a new branch on GitHub related to the issue.

So the two are synced together and moves to that branch.

So you're not going to change anything that's working.

And then once it's done working it triggers the post tool use hook.

That's basically does.

Okay, so we just did this.

Is this issue done?

If not then we keep working on this.

If it's done, I'm going to create a pull request everything in linear and update the issue or create new issues if needed.

And then, and only then I'm done.

Right?

And that means that I move forward, I keep building stuff and then dovetail sort of cleans up in front of me, like clears the pathway in front of me, gets me the context I need and then it also cleans up after me.

And because of the branch protections on GitHub, and the pull request and the heavy documentations and the automatic deployment, everything's pretty automatic.

And there is literally zero chance that Claude code this way can actually like fuck stuff up for real during development.

And the interesting thing is because this way the whole context is now externalized inside the commit messages in GitHub and the linear documentation.

Now the agent always has really good context even if it doesn't have that in its memory.

So I can just say hey, tell me what to do, I want to build this ALFREDOS cloud and tell me what are the stuff we should do.

And then it says hey, so we have five milestones.

Milestone one requires six steps.

And I actually said to Claude, fine, in that case launch six agents.

for all of the my.

Of all of the my install steps, make them write whatever needed to be built and then launch another agent that orchestrates it and tests everything.

And then because the hooks deterministically enforce what to do and how to go through that, it always works the same way.

So yeah, that's what I'm working on right now with Dovetail.

And I'm pretty sure that I can, I can release it soon.

It's again, it's not stable, it's not working.

But anyway, I'm going to release it anyway.

yeah.

So where are we?

Okay, so that was daft there.

And again, so you go into here and then you can actually look at the issues and everything that's in here.

So everything that, that I'm building is documented in here.

this documentation is done through like a earlier version of Dovetail.

So this is fully automatically built.

The whole linear, I never open linear.

okay, so let's go back.

So the next thing is Joe.

Now Joe is interesting because it's a voice agent that I'm building for a construction company.

And we have a couple of stuff that we need to adhere to.

One, Joe needs to have.

There you go.

So Joe needs to have a less than 10 cents, per minute, cost.

has to have a less than 500 milliseconds latency.

and also has to.

We have about 30 different tasks that the client said they want to have.

Johan, we need to have at least 60% coverage.

We need to have at least 80% success rate.

Right?

So again the kind of, the problem is that because agents are doing stuff on their own, achieving this is actually not very easy.

so at first what I was doing there was also an evolution to this.

Right.

So at first what I was doing is let's go here.

So at first I figured I would build.

had an N8N, chat agent before we said we would want to have a, voice agent.

And I moved the N8N chat agent over to a customer built, app.

So I actually built a voice agent using the OpenAI, time API, which was expensive, but it did the job really well.

And there was one big problem that we couldn't really do anything with it, which is Joe has to be able to do stuff, but also has to be able to interrupt me.

So this is actually an interesting problem with voice agents, right?

Because it's usually one directional.

I call the voice agent, I say, hey, I Want you to do this and that.

Okay, I'm on it.

Wait for it, wait a second.

And then it keeps doing it or it gives me a call and we start having a conversation.

But it's all happening synchronously.

And what I want to do is let's say I'm mid call, right?

And what I can do is I can say, okay, hey Joe, I want you to do this and that.

Let me know when you're done, Bam, hang up.

And then when Joe finishes, that could start another trigger that says, Joe gives me a call and says, hey David, I'm done.

Da, da, da.

But what happens if I want that to happen mid call, right?

What happens if what I want to do is say, hey Joe, I want you to do this and that, and then says, okay, I'm doing that in the background.

Is there anything else you want to, you want you to want, want to discuss?

And while we're having a chat, if, background task is completed, whatever, we're done.

And whenever I stop talking, slide Joe.

Okay, thanks for that.

By the way.

I just got the message.

Here is the result.

Do you want to hear the result of the previous query?

That kind of interaction makes the whole thing really, really, realistic.

And it's very, very hard to make it work.

So I started working on a custom built app.

But then the whole logic was a bit, challenging.

And then I moved the whole thing to the ElevenLabs Labs conversation agent.

Conversation agent, which does everything perfectly except for this.

This bit.

ElevenLabs agent cannot deal with the interruption stuff.

It cannot like have proactive mode for a voice agent.

And then I move, moved over to vapi, which, which through the VAPI API, it is possible, it is possible, but you need some extra plumbing.

Right, but need plumbing.

because basically what we had in here was we had Joe.

Let me, let me just explain.

So Joe was a VAPI agent.

And then what I built first was Joe had N8N workflow, right?

And that N8N workflow was called through, MCP call.

And I also experimented with an MCP call or a direct function call.

it doesn't really matter, whatever works.

But what happens is that I'm having the conversation with Joe.

So user says something and then Joe says something back to the user, but also routes the task back to this, N8N workflow.

And then whenever the N8N workflow is done, that workflow then calls the Joe, agent and Joe proactively Starts talking to the user like mid sentence.

Right?

Now the challenge with this was with, as always with N8N.

So I was looking at different ways of making it work.

And the big problem that we had with this is even inside N810, you know, it works really well, but it took a lot of debugging.

But the really, really big problem was that Joe's task list here, right, we needed to have 60% coverage and 80% success rate.

So what I would do is I would take a task number one, task number one and then actually take a look at all the tools Joe can have, which is just, you know, business data, MCP connections MCP connections.

There was an ERP system the company uses.

And basically a task needs to have a set of instructions, in sequence to complete, like for example, step one, tool call one, step two, tool call five, and so on.

And I want that to happen exactly like that.

And that's when we had the challenge, same challenge that I was dealing with Alfred, which is if I just give it as a prompt, then sometimes Joe will do it that way, sometimes Joe will not do it that way, which is a problem.

Right?

Especially because what if, this tool call one, tool call five, what if that's not actually how it works?

the first idea I had was that had a SQL database connection.

So every tool call would be an execute SQL tool call.

And the idea was, is that send, I would send a prompt and then once I send the prompt, Joe, the agent would understand or translate translate prompt to a SQL query, run the query return answer.

Which seemed nice, but what if I want the financial projection based on the last two quarters of data and I want to know how much bonus I can get out of the company for Christmas?

That's not a simple solution.

There's a lot of very complicated SQL queries that needed to run.

And I was just kind of waiting for stuff to happen for minutes and that wasn't really useful.

That's when the client said that actually we should have sort of a less than two minutes, completion in order for make it worth to have a live conversation.

so then I started translating these tasks into tool calls.

But then the question is, how do I do that?

Do I create an 8 and workflows like, an 8 and workflow per task?

That's not very scalable.

Right?

Every new task we would need to create a new workflow.

So that's not what we want.

if I just use the prompt, it's unreliable Unreliable, so what can we do?

And then turns out that we needed to have a new MCP connection for the ERP system.

And that was really interesting.

That was not a simple problem because what I had to have is we had the old API for the ERP system which was not built for agentic execution.

And also it was not built for human work.

Right.

It was a technical API.

So it was following a technical logic.

I needed to build a new API, for operations.

So instead of having an API for different database operations, I would have an API for I don't know, updating a, like creating a status update or notifying stakeholders in a project or something like that.

That.

Right.

Or creating a financial projection.

And then I ended up creating a I think there's 84 different API endpoints.

And then turned every endpoint into an MCP tool.

And that means that our Joe MCP connection can now understand those 48 actions with schema.

So it doesn't have to always figure out what the query is, it just calls that API endpoint.

But in order for that to work I would need to basically Translate task number one to a sequence of tool calls from that one, from that 48 bucket.

Like how do you express task number one as a sequence of these 48 tool calls?

And once we had that we, the system now works in a way that I just ran the evaluations yesterday and exactly there.

So out of the 30 tasks we have 80 task coverage.

there are, if we add, if we add three extra MCP servers, stuff like Gmail, weather API and that sort of thing, we actually go up to 27 task coverage.

So 60% goes up to what, 90, 95%.

I don't even know what the percentage of that is.

Anyway, so we're almost there.

And then also had a median 80% success rate.

That's success rate in the evals, that I think it's actually higher.

But there were some logging issues right.

Like not all the MCP tool calls were actually logged in the evals.

And the way it works.

It did, it does have.

So Joe has a VAPI custom prompt and custom system prompt.

And there are two more interesting aspects of it.

One is it runs on a Groq infrastructure, Groq inference.

It runs llama maverick 17 billion parameters.

And this gives us an exactly 0.1 dollar per minute cost and the 475 475 475 millisecond latency.

So if I'm Looking at these parameters, this works, this works, this works, this works.

This also kind of works.

I think I'm not really logging execution time yet.

So that's where I'm at right now.

so yeah, there is one more thing that makes things faster and this is this part and that is the memory layer.

So looking at, looking at memory, I said user prompt.

Joe calls Joe mcp.

Done.

What if I say after that save what happened to memory, Both what the user asked if that was good and the actual output.

And then I would change the process as well.

So I would go this and then also memory.

Right.

So instead of trying to do everything right away, I would want Joe to just get stuff from memory.

And for that I'm using MEM0, which is pretty cool.

And they just got a bunch of funding so I'm pretty sure they're going to be raising prices soon.

There is a startup pack package and yeah basically you go to Smithery and inside Smithery there are a bunch of, there are a bunch of mem0mcp servers and there's also an official one.

But honestly it wasn't working.

at least it wasn't working for me.

And I don't know what was the issue but all the MC, all the MEM0 MCP servers had the same issue.

So I built one for myself and you can find it as a David AI.

that's what I built.

And it basically only has two tools.

It adds a memory and it search memories and that's it.

So it does exactly what we want it to do.

I say something, search my memories to see if there is a relevant bit and then if no calls the JOMCP and then says what happened?

If there is an actual memory then just immediately answer it without moving forward.

That actually sort of a memory caching, that makes things work a lot faster.

so that's the Joe project and I'm hoping to hand it over soon.

because we are at the last stages of this work and then there is the last project which is Jig.

And that's the most interesting one right?

Because Jig is nothing else than is a cognitive assembly line.

Now this is interesting because there is again same problem like N8N versus agents, right?

I've been talking about it a lot because with N8N you have deterministic plumbing but you have deterministic workflow and manual plumbing.

Which means that if I want to create a five step process I actually need to create a 50 node workflow because JSON, expression, aggregate, merge, custom JavaScript, whatever.

And then if anything breaks, the whole thing breaks.

And then anything also cannot just resume from that step unless you're saving executions properly.

And it's just very complicated and very brittle.

But if it works, right?

If it works, it's great.

If it doesn't, you're debugging at 2am and you don't know why.

And that's, that's the big problem.

And also it gets very, very complicated.

Like the graphs are so complicated.

And then you have, you look at agents, which is, you know, chatgpt, Agent, Manus, whatever.

And then they are probabilistic so they drift off and hallucinate.

But they can be resourceful to, right?

So if, let's say a JSON is broken and and N8N breaks, manage or chatgpt agent or cloth code, it would just figure it out.

So, hey, looks like it's broken.

It looks like there is an extra comma there and I need to remove.

And that's it.

And you know, I don't want to be debugging at 2am because of an extra comma.

I want the agent to automatically figure it out.

So what happens here is, do you have, you have a bunch of nodes?

This is how Nadan works, right?

You have a bunch of nodes, that's it.

and then you also have a trigger and that's it, that's how N8N works.

And then you have an output at the end.

Okay, so the agent works differently, right?

The agent just sits in the middle and just dust things as a black box.

You have zero control over what's happening.

Or you can build an N8N workflow in a way that it does stuff similarly like this.

It triggers an agent, then it triggers another agent, then it triggers another agent and then it generates the output.

That's actually not a bad idea.

But then the problem is basically the payload.

So let's just add a bag, right?

Here's our payload.

So all the information that we send over here, these are all custom designed, right?

Inside N8N, you need to tell what are you sending off to the next agent?

What's the context that it should be getting?

Right, so you need to be manually designing every single bit.

However, inside an agent it just gets an idea and then it figures everything out on its own.

But if you want to build AI agents inside N8N, you have to still do the same plumbing thing.

So that means that even though it might work, you still need to deal with jsons and commas and whatnot.

And my idea was that, what if we had this logic, right?

What if we had this logic, but whatever the payload is, this would be managed somewhat, I don't know, somehow it would be managed differently.

It would be managed, with purpose, with intent.

Like, how would that look like, how would, how would it look like if.

Oops.

How would it look like if I wanted to intelligently pass on context so the agent can actually understand what the other, what the previous agent did, but in a very compressed way, so it doesn't bloat, doesn't get bloated.

And that's when I went to CLAUDE code, because I felt, okay, so what happens if I start claude?

Let's say I would start CLAUDE code, I would give agent an MCP tool number one.

And I also give it a simple prompt and prompt for a single task, right?

And then whatever the output is, I don't give a shit what the output is, just send everything over to the other agent, figure out what the ideal output should be, and then the next agent would do MCP number two with another prompt, single task number two.

And that means that basically we are launching new agents for every single task, just like what we did with NA10.

But then the context is decided.

It's just, everything is just shoved over together from one to one to the other.

And here is the problem with this, right?

The problem with this is that basically it's like you launch Claude, CLAUDE code, you turn on some connections you have, you let it run, then you turn off those connections, give another prompt, but new connections, and then you run it again and again and again and again.

And because it's the same session, it's actually very hard to make it so that you know, you, you either have to manually turn everything on and off all the time, or if you don't want to do that, then you need to figure out how to, how to restrict tools per each agent run.

And you either, to solve that, you either have to solve the N8N problem.

So instead of sending everything from one agent to another or using the same agent again and again, you need to figure it out manually what to send over, or you need to have a system that manages contacts between these agents at a very, very effective lossless compression, while also orchestrating the deterministic part of do this task.

This is the tool you use, this is the input I'm expecting, this is the context, this is the Output I'm expecting, and that's it.

And then as those things run, then the agent itself, basically does everything, which means that the macro bit is completely deterministic, the micro bit is agentic.

And that hybrid between context was really important for us because the idea was what happens if this is a human and not an agent?

So right, what happens if I want to replace one with another?

Then how do I feed the right context to the human without overwhelming them?

It has to be, and this was one of the key ideas of jig, that it has to be intelligence agnostic.

It shouldn't matter who the human is or who the actor is.

Like, is this a human, is this an agent, is this a manager, is this an engineer?

Like everybody should be able to do it.

And the way we did it is we created the jigdsl, which let me start with another thing.

So we created a framework, the IKO Framework, which really just on stuff like jobs to be done and other frameworks.

The idea here is that in an AI native world, every task you do inside a business, can be described by these four things.

Let me explain.

First big statement around JIG is that every operation is a CRUD operation.

Everything you do in your business is a CRUD operation.

You are creating, reading, updating or deleting some row, some value in some database, even if that database exists in your head.

so the question is, how do we get access to all the databases that we need to do and how do we actually describe these CRUD operations?

And that's when we came up with this IKO framework, which means that in a truly AI native business you would have every CRUD operation has an intent, has some relevant context, a specific action you do, and the specific output.

Right?

if you remember, it's like the jobs to be done framework says that you don't buy products, you hire them to get a job done.

Right?

Me wanting to get a job done is the intent.

Why I want to get the job done is also part of the intent.

And also once the job is done, how do I know it's done?

That's my output and getting it done is the action and then how to get it done and what you need to get it done is the context.

So ideally, every action inside the business can be described by this framework, which means that you know, we have a specific action.

Let's say you have a task that can be described with this IKO framework.

What happens if you create a workflow which have three tasks, three tasks in it, the workflow itself can also be described with the IKO framework.

And then what happens if you have entire business units that have, I don't know, five workflows in it?

Then again that can be described.

So it's really like a fractal pattern and that's why we called it the IKO fractal.

Now in order for this to be translatable into agentic work, we really needed to have a very specific, very efficient compression of information that is understandable by humans.

And that is the jigdsl.

It's a YAM based language, which really just describes these intent, context, action and output in a structured format.

And then once we have, once we created that, so we had the intelligence agnostic idea, which then led us to the IKO fractal, which then led us to the jig dsl, which then led us to the idea that ideally I should be able to create a database, right?

A jig database, jig database that, where I can just take a, workflow description that's described in this yam and then every, every part of this yam is translated into some database entry.

And once I have that done, I gain a really interesting thing because now I can orchestrate work through a database instead of through code.

N8N orchestrates through code, make orchestrates through code Zapier orchestrates through code.

It's not very durable.

So if I orchestrate everything through a database which is execute task that has an ID ABC in this database, and here is all the configuration pattern of that inside this database, then it becomes very durable.

If we actually log every, every step of the way.

so we would have like a run, log in the database that says, okay, so step number three.

This is what was the input, this is what happened, this is what was the output.

Then we got an error.

So instead of redoing everything, I immediately have everything saved in the database that says it failed at step number three.

We just want to figure out how to make it work.

So inside this JIG database, right?

I would have, I would have tasks somehow explained.

tasks explained.

I would have workflows explained.

Oopsie.

Let me just.

Okay, so we would have tasks, which we call stations and workflows.

And let me explain this.

So we call them stations because when Henry Ford created the assembly line, what happened is that before Ford, before the assembly line, Craftsman, Craftsman owned production end to end, right?

And then after the assembly Line after the assembly line, factory workers owned specific task.

Now why did that happen?

It happened because Henry Ford a research and a study on his own factory and realized that because a craftsman was owning a longer process, they had to work around the factory.

So if there was somebody who was working 10 hours a day, they actually were pedestrians.

In 40% of the time, it's not factory workers, it's pedestrian.

You walk around for four hours and do actual work for six hours.

So instead of humans going to the work, he asked, how do I eliminate people being pedestrians?

And the answer, let's go it the other way.

Let's not have people to go to the work.

Let's have work to come to the people.

And that was what the assembly line became.

Now how does that translate to work, right, inside knowledge work.

you have problems, right?

And that means that you own the problem end to end.

So as a knowledge worker, you have a series of problems that you need to keep solving all the time, and you own it.

You have full ownership of the problem.

You need to know when the problem arises.

You need to know when the problem needs solving.

When problem needs escalating, you need to follow through.

You own the problems end to end.

And then the big problem is that problems have lots of smaller problems, lots smaller problems, that require different context.

So then this is the key, learning here is that we had pedestrians, pedestrians for factory workers, right?

We know that they weren't as productive because they were being pedestrians.

They were working around different, parts of the factory.

What's the knowledge work equivalent of that?

And the knowledge work equivalent of that is context switching.

Because different problems require different context.

So if the solution for pedestrians, for making people not pedestrians, was to make people make, move work, not people, right?

Then the idea here is that we would move context, not people.

So, the cognitive version of an assembly line is that the context always comes to you the same way, but the task itself never changes.

And that's a big problem because human work is messy, it's random.

And knowledge work is messy and is random.

So we really need to figure out how we can manage context.

And that's the most, interesting part of jig, how we manage context.

I'm not going to go into the details.

There's a whole context layer and the context ledger that connects everything.

but the point is that you have this jig database that creates the foundation for all this.

If I move here.

So here is a specific, jig run.

As you can see, there was an actual execution by an agent.

It cost 2.86 cents.

we had a specific type.

Here is a number of tokens that were created.

And what you can see here is the full execution log of what the agent did.

And we had.

What was the intent?

I was like, search my memories about David and report findings.

And here are the tools that were used and how many times.

And you can also use, see what connections were provided, what was the actual prompt we gave.

And then here's the context block in the context ledgers.

Basically, after every execution, jig analyzes itself and says, okay, did we actually achieve the intent of this work?

And how confident am I that my answer is the right answer?

and then it also writes a report, that's human readable for later.

If I say let's create a file, it saves it to an artifact as well.

So, and then I can take a look at all the workflow history as well.

And then there were a bunch of evaluation stuff because, the idea here is that if you have this, you can use Jig to run evaluations.

You can use Jig to do a bunch of stuff.

So yeah, the interesting thing is now we have a Jig MCP server that creates these things.

And basically, the execution part is following this, right?

So the jig logic transports the context.

And every agent is a cloud code agent.

So it's like a cloud agent built on a cloud agent SDK.

It spins up a cloud agent, gives it the tools it needs, authenticates everything and and starts with the workflow.

Then it generates the output as specified, in the jig and then calls the next agent.

The next agent forks the previous cloth agent.

So it has all its memories.

But now it has a different task, it has a different intent, a different prompt, different tools, different access.

It's a different one.

It's kind of the same same, but different.

And then it keeps forking the cloud agents until it gets to a point that it reaches the final output and then it does the final output.

And creating jigs, out of SOPs is a really powerful thing for us now because, I got a loom video that would last it five minutes from the operations manager of the client and on how they do reconciliation of transactions at an E commerce company.

And I fed it into this jig system.

I have an architect that can transform these rule translations or raw transcripts into jigs and then implemented it.

And like with a single one shot attempt.

We got 95 plus percent accuracy in the completion.

And we're not creating new agents, we're just using existing ones.

And if you have a GAM cp then you can actually run everything from Claude or ChatGPT or whatever.

So like there are a lot of stuff that like overlap between different projects because they're all trying to kind of work in the same problem space.

the interesting thing about about JIG is lost.

The latest thing that I built is that I can, I can create a station and run it and then like as a temporary station, which really allows me to just create short lived cloth agents as part of a workflow and save all the context they generate.

It's getting very complicated very quickly.

But so this is the other project that I'm working.

I'm very happy about this project.

This is a really cool project.

yeah, so these are most of the projects that I work on.

And then there are a couple other stuff like the bootcamp is returning next week and then I also have a fun project about, I think it's here, the no Code no clue process which translates n8n workflow JSON fuzz into tutorials and radio plays.

And I started building an actual workflow to generate the content and inside an 8.

And it was very, very complicated.

and ultimately I ended up using my dovetail powered cloth code process and basically built the whole system I don't know in, in less than an hour.

So now what it does is this.

So basically it runs a simple dashboard, but it also works from the terminal.

So I have launched it with a simple command.

It says NPM run dashboard.

And then what I have here, I know I call everything Alfred.

I should really stop that, stop doing that.

So what happens is that when I start running it, it starts running through a bunch of steps and it starts generating like it starts going through a 13 step process and then if some, if it contains or encounters some errors, it can pick it up and continue on from that later.

And what happens is that it takes a look at the workflow and it understands the workflow.

So it was, it took a JSON file that was Jackie, an AI assistant.

I got it from the NAN Template Marketplace.

And then it actually tries to understand what that workflow does.

It creates an analysis and then it creates another analysis which is, you know, where does this actually solve a problem?

What's the context?

where is this an overkill?

So it generates some extra context and then as a next step it creating a script.

So it's like, okay, let's try to generate a, Hold on, there was an error there.

There you go.

So step number three is it actually, creates a script, metadata.

there is like a sitcom episode generator which has like a guide.

And I, can walk you through that in a minute.

And then it generates the pack, and from that it generates a script.

And now we have the script here, which is a pretty long script for a sitcom.

and then I'm like, okay, next, turn that into a JSON.

And once you have that JSON, I want you to go through each and every one of those and then generate the actual radio play.

So turn the script.

We have voices, assigned to different, persistent actors, permanent actors, and then there are random voices for, episodic actors.

And then it generates something like this, which is like, pretty cool.

It's full radio play, here.

And you can also check the one on the notion tripling workflow.

And it's fully automated.

Elevenlabs now has the V3 model, model available in the API.

So it uses FFmpeg, MPEG to generate all the, dialogue, blobs.

And then, it generates one big audio file for the radio player and saves it.

And then it generates some metadata, some SEO stuff.

And then once it has everything, it takes the actual workflow and then generates an actual tutorial.

And and then the last step is that it, posts it to, Ghost as a blog article.

And I'm still working on it, but I will probably turn this into like an automated regular N8N tutorial, article sequence maybe once a day.

It will help me with SEO and it will probably also you guys some ideas on how to do stuff on N8N, if you still want to go down that road.

So you can see, you know, there's like, okay, here's the source.

What tools are used, setup time, difficulty time saved per month, and then there is the tutorial.

So I'm still playing around with it.

we'll see how it goes.

But that's kind of a fun side project that I'm doing.

So.

Okay, the raw recording is almost, 90 minutes now.

So I'm going to stop talking.

There's a lot of stuff that I'm working on right now, as you can see, which, I just wanted to start talking a bit more about that.

So I'm going to, I'm going to share the linear document, the linear roadmap, links and I'm going to just start uploading YouTube videos separately per project and then also sending out different, different emails, like on a weekly basis.

So thanks for watching.

If there is any questions you have, I'm always an email away.

And, yeah, which project you're most excited about?