All right, looks like we're live.
So if you guys are watching this for the first time, we are going to start streaming to Facebook.
We normally don't stream to Facebook, but normally all of our streams are on YouTube
and X.
And so we have a development agency that we've been going since 2010.
And just recently we've been dealing and experimenting with a lot of AI, as you can imagine.
Someone recently asked me, like, oh, aren't you super scared about how AI is changing
code?
I was like, no, this is the best time to be alive as a developer.
We were able to improve our process.
We spent a lot of time the last 12 months kind of working on our process as far as getting
really, really smart about shaping and framing projects really well, breadboarding things,
and helping do kind of the thinking side of it first.
And then eventually moving that into then leveraging the AI to go execute on all this
as well.
So we're building some new tools every single week.
And so rather than me try to build some playbooks for our team, we're just hopping on once a
week and just talking for an hour and kind of showing what I'm doing as far as process
goes, what some of our team are doing.
So if you think that's cool, follow along.
We'll try to keep these coming each week.
And if you're interested, we actually have a whole course now.
So if you're looking at the description, you can jump on that course.
And we have all this kind of broken into a course.
And you can check out our workflow and some of our best practices.
And I think we even have like all of our long sessions we had with Ryan Singer are all in
that course as well.
So check that out.
So I'm going to jump over and like talk a little bit about our process as it stands
today.
I've got my team around here as well.
So we may jump on if they have questions or you guys want to comment on anything, just
message me there.
So one thing I thought would be helpful would be like to go through like a reactive task.
So typically we have like project work, which we've talked a little bit about previously
where we may have like a bunch of tasks where we like break things into task grid or something
where we frame it.
Last week, we went through and actually a little bit of a project within a project here.
So we took our dashboard and we just framed a project.
So we kind of figure out what the problem is.
We figure out what the outcome is, what's out of bounds, what the appetite is.
So this is typically what a document looks like when it comes into our system.
So when you're starting any new project here, this is sort of the flow is to get a framed
project.
There's a whole process for doing that.
We drop it in here into our dashboard and we can present it to the client and then we'll
actually get a signature or sign off from them to move this out.
And this kind of becomes our contract.
It's not solutions based.
It's very much like here's the problem and here's what we want the outcome to be.
There may be a bunch of solutions that help us get to this outcome.
So it gives a little bit of flexibility to that.
And then we get very specific about what we're not doing.
And this typically creates a much more precision around sort of the frame of where does this
project start and end.
Once we do that, we move it into get really specific and we create a task grid.
And so I show these to you here because we have like some MCP tools and a CLI agent now
that we're using that will help you organize these.
And you can actually sign in like from the terminal or you could use Cloud or you can
use chat GPT and connect by MCP to the dashboard and have it write all these tasks up for you
very quickly.
These are all super awesome tools to help get things out quickly.
And then recently we've also added this task piece, which is actually connecting to Notion
now.
So we can kind of have a task grid, which is like go build a new feature, slice it up
into different verticals.
And then task is kind of like reactive work.
So I'm just going to show you like the workflow I used for a reactive task yesterday, kind
of how that flow went from, you know, from getting the message to like how we framed
it up and then how we used Cloud to like basically write up a plan for it.
We wrote the plan back into Notion and then we went and executed there.
So I'll just sort of talk about the process here.
So a client typically like comes in here, they give us a new Slack, I mean, a new task.
This could be like in Slack.
Yesterday it was actually in a text message, which is like my favorite way to get reactive
work.
But Slack, maybe it's coming through an email, something comes in the door here.
So typically what we do is we would actually start this by essentially kicking off like
a new thing here, which would be just to like, I would say just the planning.
piece. So we take everything we know here and have your, and I'm just going to, I'm going to use
Cloud or AI kind of interchangeably. I'm using Cloud for everything. I know some people using
Codex or using other LLMs, but I'll use AI and Cloud interchangeably, you'll see.
So we'll say AI, basically like discover the project and then also go and basically write a
plan. And this will be written into Notion. So I'll just go ahead and try to do this for you
guys live. So we have a project here. I'm going to open up terminal and then let's just get this
cleared out here. Make it nice and big. Oops. There we go. Sorry. It's a little bit weird
with the screen share here. Okay. So we'll go ahead and kick off Cloud here and I'm going to go
and grab a task. So let's, let's go into Slack. So we actually have a task here where
one of our friends, Steven, sent us a task to notify groups. So luckily, nicely,
he did here for us was to actually give us a video. And the best thing about video is a transcript.
So I'm going to just take all that. We've exported that. I'm going to just save it to
like feature idea here. And I can now bring this into my chat. So I can do this obviously in the
terminal. I'm also going to like show you guys, like you could use Cloud directly to do this.
If you want to use the desktop app, I've been using them together quite a bit. So it doesn't
have to be quite as technical as using the, using this here. So what I'll do to speed things up is
to grab that file real quick. I'm just going to paste it in. I'm not going to, I know Lucien's
probably paranoid. We're going to blow some tokens real quick. So I'm like, help me like
frame this project up for, it would be like tribe social reactive, like for March and make like,
so I'll just say like planet. And then, and this feature, actually this particular one is in a,
in a different, let's just do this real quick. I'm going to switch it to this.
Okay. I just have them in two separate projects right now. So let's go over here, help us frame
this up. And I'll go back to my text here, planet, and then like make a task in Notion
using Lenovo CP and set to like dev ready. So now I'm going to just paste the transcript here
and let it go and turn. So we're in plan mode. I'm going to kill this. And I do this in the project
because then it can go and actually use the context of the project itself. So it's going to
give it a second there and what's going to happen, we're going to see this happen here sort of in
real time is go over to Notion and I'm going to go to our tribe reactive. So come on, where's my
shortcuts? Okay. Reactive. Oops. Sorry, my keyboard just seems to be not liking the screen share.
March 26. So this is how we track little tasks of bugs that pop up. So yesterday, while that's
churning behind here, I took a bunch of new features that were happening in like our chat DM.
And this is kind of what it did. Like I wrote the plan up and then it came in to Notion
with a full plan. And I just liked it in here because it helped me track where it was in like
sort of my interface back to the company. I'll show you as well, something that we're starting
to draw a little bit more as a team here as we're kind of thinking of like this is like we've built
this sort of centralized hub of knowledge using the MCP and the CLI. And you can like, there's
some API stuff here. And the dashboard, which you saw over here is like one layer to that. We have
a client dashboard of a team dashboard. It's all kind of in one, it's sort of our default UI layer.
But I can also sit here, like some of our team members can sit there. We use Notion as a tool,
but I'm just using Notion. Notion's just reading what's going on in here. And my MCP is just
talking to what's going on in here. Notion happens to be like a nice way to view all that,
that has statuses and tracks it. And I can just see it in like a familiar view. But what happened
is a new task came in here and then we pulled the task down, we worked on it. And then you can see
Claude made notes in the comments here.
so I could track what it was doing.
And then I can always assign this to a different team
member if I wanted.
I can change, obviously, the status.
I can move them around from there.
And so let me see where we're at right here.
I have a pretty good this.
And I have not framed this beforehand.
I'm just doing this all live.
So we'll see how great or not great it is.
And perfect, it says there's no MCP.
So this is going to be a great, very fun demo.
Even though it does have MCP, so let's just teach it
something real quick here.
We do.
It's probably running.
Great, great example.
So I will stop sharing for just a second.
Get CP to back up.
Let's see here.
I think I'm not going to be able to do it without you guys seeing it.
Demo-linus.
Yes, this is a real demo.
So we'll go through this and just see frame up.
So what you could do is show you, like,
I haven't even watched the video yet.
Now, I did watch the video.
Steven, if you're watching this, I watched the video.
But I'm just, this is how fast.
I don't have to watch the video.
I'm taking the transcript and I'm shoving it in here.
And it's basically asking for, it's
starting to put a plan together that then we can just
create the task and then hand this off to a developer.
Or if you want to go work on it yourself, you can too.
So it's kind of getting hung up on this MCP stuff.
It's probably because I moved this directory right
before the call.
I had tried to be fancy and organize some things.
Let's just do this as like a, we'll just, yeah,
we'll just go ahead and have it.
Sorry, go through this here.
So we'll skip the Notion piece.
You can, with one prompt, basically
have it write it all to Notion, make the new task, which
is kind of a magic trick here.
And so now it's kind of written up this.
Now, this would be like now for a developer.
So the reason I wanted to break it into Notion
is that if you were just capturing
this task from a client, we could just write this back.
You don't even have to know what any of this
is, but you can kind of write this in so that it kind of comes
in with a very specific.
I used the word frame, and so it got a little carried away
and framed the task, which is kind of like a little mini
project, I guess.
But we can kind of read this now in a much better way,
because when it comes in through Slack, it's a video.
So I'm going to have to watch the video.
It's two minutes.
We have to kind of understand what they're wanting to do.
What screen does this actually connect to?
What other problems might this cause if we added this?
But this helps us just kind of put it
in a much easier-to-read format.
So they're saying like, hey, there's
admins who manage multiple communities on Tribe,
and they send the same notification
to several groups at once.
Today, the flow is that you open the notification form,
you select one group, fill in title, you hit Send,
and then you repeat steps one through four
for every single group.
Steven, misspelled, and it just guessed it,
like made up a company that it's not connected to,
reports doing this four times per session,
and it's kind of a pain.
And so the solution would be to have some sort of multi-select
groups.
So admin can pick two groups, and they only have one API
call, and it does a bunch of stuff here.
So the front end, so now, see, I've got very specific now.
Like, hey, we're going to replace a single group
dropdown, the multi-select dropdown.
Back end needs to accept these different group IDs,
and then deduplicate a bunch of stuff.
Firebase is storing that.
OK, blah, blah, blah.
So it's kind of got into the weeds of it here.
It's using definitely an older training here
on what framing is.
I'm not sure where it got these no-gos and rabbit holes.
We don't use that so much anymore.
But it's got a little notification
into implementation plans.
This could kind of help get the task in,
and we could sort of dump that into Notion,
and then we could assign it to someone.
So this is a great little pre-step
to getting the project in.
Now, it would be good to read through this,
make changes to the plan, but then you
could use the MCP to pull the task down,
and then work on it, and kind of work your way through that
as well.
So the main thing here would be to show you
how it writes to Notion and comes back,
and then how you can pull tasks down from Notion as well.
So maybe I'll take a second and get that,
or maybe just be better prepared next time for this demo.
But that's sort of how we would go about pulling this in.
Let me go back to my little diagram here.
We'd pull this in, we'd plan it here.
And then this would send it to Notion.
This would actually do the planning piece.
And then I'll put this under the human part,
but it would essentially, like, right here,
we'll actually write to Notion.
and write up a plan and a task in Notion here,
which we can review and comment on and do things there.
So it kind of makes it a little more accessible again.
And then anyone on the team could actually
pull that task, kick off, basically,
start a work session.
And we can kick it back over to AI
to go ahead and do that task.
Once it's finished, then it kicks back to review.
We're talking about one day having it run local tests.
But say it would run it, and it would comment here
and give us a PR link, essentially, to finish that off.
And so what we're doing is we're still using the human layer
to do the planning.
We're still using the human of when to start it.
And it has to review the plan and make sure
that it actually looks like a solid solution.
But a lot of the time as well, we're
talking even about simplifying this.
Once it plans it, don't worry about this is sort of the,
I'll put this in a different color.
But this is very much like a safety net right now.
In future versions, why would you not just do this?
Why would you just take these two things out?
Plan it, finish it, and then just comment back.
Because coding is so cheap and tokens are so cheap,
why would we just not let it just take a stab at it?
And this is actually what I've been doing recently,
going into the planning, reviewing it, and just
executing on it, and letting it go right back
into the first time I look at it,
again, is when it's in review mode.
And this starts to get into what I'm referring to now
as somewhat of a code factory, a small version of this, where
you basically have tasks being built up here.
And then you can kind of see what
the AI is working on in the in progress.
And then it's being moved to in review.
And then a human is coming back into the in review piece
and moving them into completed.
Or you can basically click in here.
This is a bad example.
But if this was an AI task like this one,
I can select this, go into Cloud, and say, hey, work on,
and then paste title.
And it will just go and find that task somewhere in Notion.
It'll pull everything in the plan
here, which you can see is quite extensive,
plus all of the comments it's made,
so the incremental updates.
It kind of uses it as memory bank.
And then you can keep working on it.
So this happened as well, where it went into review.
And I was like, great, this is perfect.
I mark it as completed.
And then I go into something else.
And then I find out there's actually a bug that happened.
So I basically bring it back out.
We work on it again.
And so you can see there's kind of some different work
sessions here where we went back and forth on that.
And I did all this in a separate branch.
And then we just did one PR that moved all four or five
of these somewhat related upgrades
to this one chat component, all in one move.
So that was kind of the flow yesterday.
I basically took these two steps out
and just went straight from planning directly
into do the work.
And then what I was doing is just sort
of monitoring it in real time.
And so maybe there's some overlap here,
where it was probably just an observer.
Because this is a mobile app, so we kind of have to test it.
It's just easier to test on my physical device.
I did all that, marked everything as completed,
pushed it all to web, sent it off
to the production for the web.
And I was like, I'll just set up the iPhone.
And I pulled up the iPhone, and half the things
didn't work once I switched to a real iPhone device.
So then I had to go back into it.
And it was pretty easy at that point
to just prompt it a few more times to fix the iOS version.
So that's kind of like our flow.
Hopefully that's helpful to some of you.
I'll pull this up as well.
We did add this AI course I mentioned at the beginning.
So this course, our team has gone through this.
You can see this little free about how we frame, shape,
and ship projects.
And you can see all the framing stuff we talked about,
how we're building, how we're communicating with clients,
doing AI stuff.
So we're looking to build our team this year.
So if this stuff is interesting to you,
and you'd like to nerd out about it, dive into the course.
And then definitely connect with us, and we'd love to chat.
So I'll probably end the stream there,
and then we'll hang out with the team,
and we'll do some more conversation.
So thanks, guys.