文字起こし 🔗
WEBVTT
00:00.000 --> 00:06.649
For me, the plan mode tactical context engineering, spec driven is strategic context
engineering.
00:06.649 --> 00:07.911
That's how I think of it.
00:07.911 --> 00:09.693
Because you are thinking long term.
00:09.693 --> 00:15.438
Because if I'm going to be writing code, I'm going to live with AI written code for six
months, one year, two years.
00:15.438 --> 00:17.160
And I need teammates involved.
00:17.160 --> 00:18.821
I need a collaboration pattern there.
00:18.821 --> 00:21.531
So that's where I need durable context for that.
00:21.586 --> 00:28.561
Hari Krishnan's long career in software development spans enterprise, consulting, and
startups, including three where he was a founder or co-founder.
00:28.561 --> 00:34.996
Today, he's the founder and CEO of Polarizer Technologies, which he promises, the name has
nothing to do with politics, it's about physics.
00:34.996 --> 00:39.309
Polarizer helps enterprises adopt AI augmented development practices at scale.
00:39.309 --> 00:46.303
He has over two decades of experience spanning platform engineering, building product
startups, enterprise transformation projects, and technical advisory.
00:46.303 --> 00:51.666
His recent work at intent-driven development has been fun reading for me, and I've been
working on getting him on the show.
00:51.666 --> 00:55.425
Hari is also our guest today on the Engineering with AI podcast.
01:12.484 --> 01:14.224
All right, thank you so much for coming on the show today.
01:14.224 --> 01:15.290
I really appreciate your time.
01:15.290 --> 01:20.282
Hello Kyle nice to meet you and again thank you for having me on the show, very glad to be
here.
01:20.282 --> 01:20.962
Glad to meet you.
01:20.962 --> 01:26.186
We never got to work together, though we have some colleagues and friends in common, so
that's always nice.
01:26.186 --> 01:32.659
So like I mentioned in your bio, what you've been writing about on intent-driven
development is some really great reading.
01:32.659 --> 01:40.808
I'm considering you sort of a go-to source for people thinking a lot about spec driven
development, for instance, which I'll be honest, I haven't done a ton of this.
01:40.808 --> 01:50.467
I do tend to write a fair amount for Claude or Gastown Mayor or whoever it is that talking
to, but I don't tend to spend a whole lot of time thinking about things as specifications.
01:50.467 --> 01:54.120
think of it sharing the context or talking about the domain or something like that.
01:54.120 --> 01:56.943
But I know that there is a whole ecosystem around it.
01:56.943 --> 02:01.979
So can you talk a little bit about your article at InfoQ and how you see this space?
02:01.979 --> 02:02.329
Awesome.
02:02.329 --> 02:04.331
That's a great question to get started with.
02:04.331 --> 02:13.726
In fact, my introduction to spec-driven development was early last year when Amazon
launched Kiro and it really piqued my interest and I was trying to take a look at what's
02:13.726 --> 02:14.877
going on here.
02:14.877 --> 02:24.472
So that's when I realized there is this whole point about context engineering, which is
going on essentially when we have vibe coding, like, you know, using cloud code or codec
02:24.472 --> 02:25.463
CLI for that matter.
02:25.463 --> 02:28.355
We largely have just a conversation to do a deal with.
02:28.355 --> 02:28.985
Like I ask
02:28.985 --> 02:30.926
for something and it gets built, right?
02:30.926 --> 02:34.769
But there's no durable sense to that conversation which I have with the AI.
02:34.769 --> 02:41.334
And I'm not really conversing with the AI, I'm treating the AI as a tool on the desk
rather than a person at the table, right?
02:41.334 --> 02:51.823
Like, and as AI has gotten more capable, that's what I think is a key difference to treat
the AI as a partner in thinking, to build through as to what we want to build.
02:51.823 --> 02:55.825
Eventually we did have plan mode and cloud code which kicked off quite a lot.
02:56.546 --> 03:01.900
it extensively, but then that was perishable too, because after that conversation, plans
disappear.
03:01.900 --> 03:09.038
Now they have some capability to do that, but in the long run, the details that we uh came
up with.
03:09.038 --> 03:09.979
Yeah.
03:10.567 --> 03:11.358
Nope.
03:11.609 --> 03:21.955
So what I was looking for essentially is some place to store my decisions that we arrived
at as durable context so that in future I don't start from scratch.
03:21.955 --> 03:27.890
Because otherwise all I'm left with is the code base as the only thing to look at and
start from.
03:27.890 --> 03:34.854
and oh being the probabilistic engine that coding agents and their models are, every
single time the interpretation could be different.
03:34.854 --> 03:40.057
So I don't want to, again, teach the same concepts back to it.
03:40.057 --> 03:50.654
If I were to bring the analogy of training a young engineer, I would like to give him or
her the full help that they need to begin with.
03:50.654 --> 03:53.506
But on a day-to-day basis, I don't want to start them from day one.
03:53.506 --> 03:54.516
I don't want it to be groundhog.
03:54.516 --> 03:55.417
day for me.
03:55.417 --> 04:02.783
I want them to retain that knowledge, the long term memory, but that's when I stumbled
upon spec driven development and that's where it's been going.
04:02.783 --> 04:04.084
So what is spec?
04:04.084 --> 04:13.991
So obviously that is a very, the term spec itself is fairly semantically diffused as
Martin Foller would call it and in the article that they put together.
04:13.991 --> 04:20.608
But to me, uh largely it's about durable decisions and context, way to effectively
engineer context.
04:20.608 --> 04:21.809
And that's one of the
04:21.809 --> 04:26.613
I call it intent-driven development rather than spec because spec is anything, right?
04:26.613 --> 04:30.811
But rather what I'm trying to communicate to the coding agent is my intention.
Load full transcript
04:30.811 --> 04:38.318
I'm trying to articulate it as to what it is rather than saying, hey, build me a nice
little website for signing up for my newsletter.
04:39.398 --> 04:42.149
I could dream of something, but I want to get into the details.
04:42.149 --> 04:43.811
That's where I would start it off with.
04:43.811 --> 04:46.203
And that's in my head, spec driven development.
04:46.203 --> 04:48.485
Yeah, I like to focus on intent.
04:48.485 --> 04:53.088
And one of the things I keep saying is talk to it about the domain.
04:53.088 --> 04:53.678
Tell it why.
04:53.678 --> 05:01.140
In that old, agile user story format as a this, I would like to that, so that reason.
05:01.140 --> 05:02.680
I think the so that is really important.
05:02.680 --> 05:05.672
The more you tell it about what's going on, the smarter it seems to get.
05:05.672 --> 05:12.459
And to your point, I spend a fair amount of time trying to think about what my intent is
when I'm talking with Claude, usually.
05:12.459 --> 05:16.181
or Gaston Mayer or whatever it is, and trying to get that across.
05:16.181 --> 05:19.501
So how do these systems formalize that?
05:19.501 --> 05:23.712
Or how does, maybe you have a specific system, but let's think of it generally first.
05:23.712 --> 05:29.512
How does this formalize that process of reifying an intention or saving an intention?
05:29.512 --> 05:30.495
How do we do that?
05:30.495 --> 05:36.269
Right, so maybe if I can do a little screen share that might just help to visually orient
what we're trying to do.
05:36.269 --> 05:45.857
before I get into how spec driven development itself puts a system around the context and
durable decisions, vibe coding interaction looks something like this, right?
05:45.857 --> 05:52.279
Like we have the humans, which is us, and then we're talking to a general purpose agent or
something like Claude code and this code in between.
05:52.279 --> 05:56.652
And that's both the context as well as the final outcome as we would call it, right?
05:56.652 --> 06:01.397
And at the bottom, I have something called an intent to implement implementation
deviation.
06:01.397 --> 06:02.616
I'm trying to map it out.
06:02.616 --> 06:06.380
So initially it's all great like you know we start with a little bit of
06:06.435 --> 06:07.515
We don't understand each other.
06:07.515 --> 06:13.789
And then as we iterate and give it feedback on the code that is generated, I review it,
give feedback.
06:13.789 --> 06:15.291
It starts to align with me.
06:15.291 --> 06:22.455
But then as I go along, eventually I have like a weird point at which it takes off on its
own and has a mind of its own.
06:22.455 --> 06:25.699
And I have a meltdown and the AI agent has a brain freeze.
06:25.699 --> 06:27.960
And the fundamental reason is the context window.
06:27.960 --> 06:29.591
We've got to keep that in mind, right?
06:29.591 --> 06:32.122
Which is, this is popular paper.
06:32.253 --> 06:33.174
lost in the middle.
06:33.174 --> 06:44.489
I'll share a link later for this, the whole point is the context window, however big it
is, um the more you start using it, you start getting it into the so-called infamous dumb
06:44.489 --> 06:54.898
zone of the model, and you start losing important decisions So the way spec-driven
development addresses this is largely through a way of formalizing that discussion, which
06:54.898 --> 06:55.728
we're having at
06:55.728 --> 06:56.849
with the AI.
06:56.849 --> 07:00.012
So you still have the humans and the general purpose agent in between.
07:00.012 --> 07:03.675
But what you importantly have is you're trying to engineer context here.
07:03.675 --> 07:05.517
So that becomes a separate lane here.
07:05.517 --> 07:07.090
And you have four phases.
07:07.090 --> 07:17.099
not getting into any particular tool, but my observation of the ecosystem is that every
tool largely has like a discovery phase, which is where we're trying to address what are
07:17.099 --> 07:19.602
we trying to build from a business case point of view.
07:19.602 --> 07:22.143
Then we have a design phase, which is the how.
07:22.344 --> 07:31.440
is the technology implementation for this thing and then eventually a tasking like you
know let's break this down like this is story kickoff for example right and get that task
07:31.440 --> 07:39.686
list reviewed fully and only then do you get into coding so if you notice in the swim lane
diagram the context is what you're building all the way through and it's only towards the
07:39.686 --> 07:49.346
end that you ever get to the implementation so through this exercise you're going from low
alignment all the way to high levels of intent intent alignment and only then you let the
07:49.346 --> 07:50.457
coding agent build
07:50.457 --> 07:56.386
So which means you could have it build more complicated stuff rather than simple web
pages, so to speak, right?
07:56.386 --> 07:57.116
got it.
07:57.116 --> 08:04.490
Okay, so if I think about how, especially when I'm trying to do sort of a new thing, this
is kind of what I'm doing in a way.
08:04.490 --> 08:09.472
I even went into my Claude.md and said, hey, let's brainstorm before you get into plan
mode.
08:09.472 --> 08:12.704
Because I find that once it gets into plan mode, it's really dogged.
08:12.704 --> 08:13.871
It's like, my plan right now?
08:13.871 --> 08:15.534
It's like, no, you still don't understand.
08:15.534 --> 08:19.015
So brainstorm before plan, to me, has been really helpful.
08:19.015 --> 08:22.407
This kind of feels like that, where it doesn't really start until.
08:22.407 --> 08:24.814
We've gone through a lot of phases of alignment, as you say.
08:24.814 --> 08:29.757
But maybe I'm sort of doing it informally and these tools are more formal in that
approach.
08:29.757 --> 08:31.131
Or yeah, help me understand.
08:31.131 --> 08:32.842
Yeah, I think that's a great question.
08:32.842 --> 08:34.262
What's so different about it?
08:34.262 --> 08:40.853
So the
first difference is plans for some, I mean, if you want them to be, they are
perishable, technically speaking, right?
08:40.853 --> 08:43.513
If you want to, you can retain it in the new Cloud code.
08:43.513 --> 08:47.333
Again, you can say which directory you want to retain the plan in, and you can read them
back.
08:47.333 --> 08:49.904
And that's a brilliant feature that I think they've introduced.
08:49.904 --> 08:54.695
But that said, for the longest of time, these artifacts, the context artifacts, were
perishable.
08:54.695 --> 08:59.610
Now, when I mentioned about the division, like, you know, between discovery, design,
08:59.610 --> 09:00.501
and tasking.
09:00.501 --> 09:03.162
Those are independent conversations which we're trying to have.
09:03.162 --> 09:04.663
There's a framing to it.
09:04.663 --> 09:15.211
So for example, in the uh discovery phase, we could be doing user stories and acceptance
criteria for a feature, which is a very well tested conversation mechanism to elicit
09:15.211 --> 09:15.823
intent.
09:15.823 --> 09:23.541
And eventually when you get into technology, now you discuss the technology pieces with
that particular business domain in mind.
09:23.541 --> 09:26.804
Then putting these two things together, you can task.
09:26.804 --> 09:27.745
And this creates a
09:27.745 --> 09:33.160
unique advantage which I observed in my experience, is each of these conversations are
independent.
09:33.160 --> 09:36.433
So I could do them with different models, so to speak.
09:36.513 --> 09:38.194
This could be a high reasoning model.
09:38.194 --> 09:41.136
I like GPT for putting my stories together.
09:41.136 --> 09:43.439
I like Claude to do my architecture.
09:43.439 --> 09:49.034
I like Gemini to probably task it and then eventually build it with something else.
09:49.034 --> 09:52.416
So I have that ability to split it up and use the models.
09:52.416 --> 09:56.409
And I could even use an adversarial mechanism, have this review.
09:56.409 --> 09:58.421
by another model, et cetera.
09:58.622 --> 10:00.037
So that's one of those things.
10:00.037 --> 10:02.677
Even asking Claude to review Claude is sometimes very useful.
10:02.677 --> 10:04.728
I can only imagine having Gemini review Claude.
10:04.728 --> 10:06.630
Yes, okay, okay, that's cool.
10:06.630 --> 10:13.869
So, and I think another thing you're hinting at that I maybe didn't get in my initial
question is what I described, I'm just dumping all that into context.
10:13.869 --> 10:23.881
And I mean, it's nice that, know, Opus 4647 have million token context windows, but it has
to start all over again tomorrow or even an hour from now when we start the next thing.
10:23.881 --> 10:26.438
And I have some mechanisms that are
10:26.438 --> 10:35.858
kind of get me what I want, Ian Nuttall's session start, where this session will be saved,
and it'll summarize what we learned and summarize what we did and what files we changed.
10:35.858 --> 10:38.831
And some of the intention gets saved in those summaries.
10:38.831 --> 10:41.853
Claude's own plans, I find, don't do what I want.
10:41.853 --> 10:43.874
They do something, but they're not good enough.
10:43.874 --> 10:47.656
But even the sessions that I'm saving right now are a little bit ad hoc.
10:47.656 --> 10:50.599
I have to remember, yeah, it's this session where we did that.
10:50.599 --> 10:52.891
And I just sort of have to tell Claude go read this session.
10:52.891 --> 10:54.203
This is the one that's going to be helpful.
10:54.203 --> 10:55.716
If I forget, it's useless.
10:55.716 --> 10:57.237
And sometimes they're not perfect.
10:57.237 --> 11:05.496
So maybe that's what this is adding is instead of dumping all this great context into our
million tokens of context, this is more like what?
11:05.496 --> 11:06.888
They're getting saved along the way?
11:06.888 --> 11:09.271
Are there steps here where this is getting...
11:09.271 --> 11:09.983
Cool.
11:09.983 --> 11:20.460
if you don't mind looking at some code, so that's my actual uh production, so to speak,
for my website, the intent-driven.dev itself.
11:20.460 --> 11:24.143
And these are all my features that I've built over the period of time.
11:24.143 --> 11:25.563
And this is durable context.
11:25.563 --> 11:30.558
So all that conversations which we saw there, they're getting captured as markdown files.
11:30.558 --> 11:31.959
And they're being saved here.
11:31.959 --> 11:33.560
And that's archive, which I'm sure
11:33.560 --> 11:44.663
you but eventually I have like a first-class way of representing my whole feature set so
which means it doesn't start from the code doesn't have to which means I could throw away
11:44.663 --> 11:53.007
the code for all I care and rewrite right right exactly like how Chad was talking about it
yeah
11:53.021 --> 11:54.402
yeah, yeah, yeah, yeah, okay.
11:54.402 --> 11:55.883
Ooh, interesting.
11:56.004 --> 11:58.617
Okay, okay, now I'm getting it.
11:58.617 --> 11:59.989
This is different then.
11:59.989 --> 12:01.330
All right, cool.
12:01.889 --> 12:04.002
fact, in fact, that's a great point you made.
12:04.002 --> 12:06.780
And the way I call that is the difference between,
12:06.780 --> 12:08.632
What is plan mode versus spec driven?
12:08.632 --> 12:16.450
For me, the plan mode is tactical context engineering, And spec driven is strategic
context engineering.
12:16.450 --> 12:17.711
That's how I think of it.
12:17.711 --> 12:20.254
ah Because you are thinking long term.
12:20.254 --> 12:25.999
Because if I'm going to be writing code, I'm going to live with AI written code for six
months, one year, two years.
12:25.999 --> 12:27.721
And I need teammates involved.
12:27.721 --> 12:29.382
I need a collaboration pattern there.
12:29.382 --> 12:31.795
So that's where I need durable context for that.
12:31.795 --> 12:32.675
Right.
12:32.675 --> 12:35.516
Plans will have some value in a few days, maybe a few weeks.
12:35.516 --> 12:39.428
And maybe even if we're
doing a deep dive, maybe they'll have value in a few months.
12:39.428 --> 12:43.119
But you can't just stitch them all together and have a specification for the system.
12:43.119 --> 12:45.850
That's not what they do.
12:45.850 --> 12:49.142
OK, so the goal for this is closer to that.
12:49.142 --> 12:49.843
Cool.
12:49.843 --> 12:53.244
OK, well, what's the landscape like?
12:53.244 --> 12:57.697
As I understand it, you're the maintainer for one of the tools in this space, OpenSpec.
12:57.697 --> 13:06.156
uh So what's what does the ecosystem look like you said you started with Kiro Which we had
a previous guest that talked about Kiro so that's cool But but tell us about the other
13:06.156 --> 13:08.382
ones and how open-spec compares
13:08.382 --> 13:09.463
yeah, absolutely.
13:09.463 --> 13:11.927
So in fact, I personally like Kiro a lot.
13:11.927 --> 13:14.362
They were the ones who initially...
13:14.362 --> 13:17.364
popularized the term spec driven development in that context.
13:17.364 --> 13:26.409
And they also used the EARS format, I think it stands for Easy Acceptance, whatever that
is, which is Closer to User Stories format.
13:26.409 --> 13:27.370
And I really loved that.
13:27.370 --> 13:30.741
And you could quickly switch to User Stories if you wanted.
13:30.741 --> 13:38.655
The only problem, rather, while I loved using it, it was a sort of IDE and the setup put
together.
13:38.655 --> 13:41.568
It's one Kiro download that you do.
13:41.568 --> 13:43.729
And it's not like a CLI tool, so to speak.
13:43.729 --> 13:45.301
The experience is brilliant.
13:45.301 --> 13:49.064
But that said, it's an experience you're buying into and you're getting into.
13:49.064 --> 13:50.255
No qualms at all.
13:50.255 --> 13:56.269
But then I had my own setup, like I'm a VI user, and I'm probably living mostly in my
shell.
13:56.269 --> 13:57.710
And I like CLI tools.
13:57.710 --> 14:00.732
And that's when I got into SpecKit.
14:00.732 --> 14:05.696
So GitHub SpecKit became very popular, again, around the time frame mid last year.
14:05.696 --> 14:08.278
SpecKit also introduced the same sort of idea.
14:08.278 --> 14:09.629
you could use it with any model.
14:09.629 --> 14:12.101
It's model independent, technically speaking.
14:12.101 --> 14:14.613
So that was like a big draw to me at the beginning.
14:14.613 --> 14:16.995
Even Kiro allows you to switch models if you want to.
14:16.995 --> 14:19.277
But then CLI was my big draw.
14:19.277 --> 14:23.360
So I could go into my vi setup and start using it.
14:23.360 --> 14:32.744
And then I started looking at OpenSpec because SpecKit sometimes felt a little too heavy
hitter for small little things like, you know, I'm trying to do something small and I
14:32.744 --> 14:34.967
don't want to be caught up specifying for the entire day.
14:34.967 --> 14:37.308
I want to get going with my job.
14:37.308 --> 14:39.210
So that's when I started doing OpenSpec.
14:39.210 --> 14:44.591
And eventually, that's
when this article came out on Martin Fowler about the three types
of tools.
14:44.591 --> 14:50.625
And I think Birgitta did a brilliant job of conceptualizing what is three types of
spec-driven development.
14:50.625 --> 14:57.738
One being spec-first, which is you authored the spec from the point of helping you think
through the problem statement.
14:57.738 --> 15:01.914
But the spec itself is not really a permanent.
15:01.914 --> 15:12.339
Artifact so to speak right maybe you use the spec first from there you develop the code
and then you also modify the code by hand technically speaking Without going through the
15:12.339 --> 15:19.432
spec so which means the spec and the code need not be in line with each other It's just a
way for you to get started right?
15:19.493 --> 15:30.569
It's a soft start but the reality is in due course the spec is not representative of the
actual code so that's one way of doing it and I felt both Kiro and spec kit were
15:30.569 --> 15:32.580
following into that category.
15:32.580 --> 15:33.721
But I wanted something more.
15:33.721 --> 15:37.073
I wanted a spec to be the primary driving surface.
15:37.073 --> 15:42.187
I didn't want to modify code directly because my mental model is inside the spec.
15:42.187 --> 15:46.049
So then this term comes in which is spec anchored.
15:46.049 --> 15:50.582
That is very brilliant in the sense that spec anchored is at all given points in time.
15:50.582 --> 15:58.780
Even if you're modifying the code, technically speaking, there is some mechanisms put in
place to say the spec and the code are always in lockstep, which means
15:58.780 --> 16:06.925
could technically verify what's breaking and if a new feature addition inadvertently
breaks an older feature, etc.
16:06.925 --> 16:17.642
So I wanted a spec anchored sort of tool and that's when I realized OpenSpec is having
that kind of interesting twist about it where it has a top level spec which is
16:17.642 --> 16:20.804
representative of the overall application state.
16:20.804 --> 16:30.611
So that's one and then finally she's Birgitta talks about the spec as source, which is
eventually where I want to get to, which is there's no touching the code.
16:30.611 --> 16:38.255
Any changes will always happen through the spec and that's the kind of tools that Tessl et
cetera are for example, at least what they were trying to do.
16:38.255 --> 16:44.227
I haven't used Tessl in quite some time now, but that's the kind of way of looking at it,
right?
16:44.227 --> 16:49.860
So visually, if I were to show you what this looks like, I'll just take one more moment to
share.
16:49.860 --> 16:50.753
my screen.
16:50.753 --> 16:53.180
I'm glad you mentioned Birgitta I'm working on getting her on the show.
16:53.180 --> 16:55.769
Yeah, yeah, so this would be a good teaser.
16:55.769 --> 17:00.932
think she's done a brilliant job with the kind of structuring that she's come up with
there.
17:00.932 --> 17:03.553
So this is how we looked at initially, right?
17:03.553 --> 17:05.935
Like we looked at the tooling ecosystem.
17:05.935 --> 17:09.776
We had strategic and tactical, and tactical is the plan mode place.
17:09.776 --> 17:13.498
And that's where you have anti-gravity, cloud code, and all of these tools sitting around.
17:13.498 --> 17:16.660
Now, when you come to this guy, this is where the interesting pieces are.
17:16.660 --> 17:19.763
I mentioned about spec-driven development and...
17:19.763 --> 17:21.644
the levels of spec-driven development, right?
17:21.644 --> 17:32.567
So that's where OpenSpec arrives at the spec-anchored range of things, and the rest of it,
the spec kit and uh Kiro, is more about spec first.
17:32.567 --> 17:42.261
I haven't seen a tool which I would say is truly spec-as-source, but that could be just my
lack of uh knowledge around the entire ecosystem, but at least in what I've explored, I
17:42.261 --> 17:46.311
haven't seen a tool which is like a proper spec-as-source, so to speak.
17:46.311 --> 18:01.040
well, if I may, we had a past guest on Jeff Langr and Jeff, it's not so much a tool as
like a syntax approach, but uh he's been working on this thing, AADV which I'm gonna get
18:01.040 --> 18:07.742
it wrong, but like development assisted, AI assisted development with verification.
18:07.742 --> 18:11.826
That's what it is, AI driven development with verification.
18:11.826 --> 18:13.478
And basically what he's writing,
18:13.478 --> 18:22.322
is these, uh I think of them as looking like lambdas because they have little fat arrows,
but like he'll sort of give a name to something and then fat arrow and then he'll give a
18:22.322 --> 18:24.523
description of what that thing is supposed to do.
18:24.523 --> 18:27.685
uh And it's just sort of a syntax for that.
18:27.685 --> 18:32.087
And he feeds that into like, say, chat GPT and says like, go write me code.
18:32.087 --> 18:37.148
So sort of the combination of this and an MD file that explains the kind of code that he's
looking for.
18:37.148 --> 18:38.311
And it...
18:38.311 --> 18:46.308
I don't think Jeff is claiming that this is true, like, Phoenix architecture, like, he
could start from the spec, but I think he thinks it's a very good way to be sort of test
18:46.308 --> 18:47.549
first, at least.
18:47.549 --> 18:52.789
So, yeah, it's possible that something like what he's doing there could be seen as spec as
source.
18:52.789 --> 18:54.791
It'll be interesting to find out.
18:55.713 --> 18:56.285
Yeah.
18:56.285 --> 19:01.065
That kind of leads into what is the specification format which you rightly put in there,
right?
19:01.065 --> 19:04.196
Like, you know, does the format lend itself for verifiability?
19:04.196 --> 19:08.356
Like if it's just plain English, then obviously there is lot left to interpretation,
right?
19:08.356 --> 19:14.087
If there is some sort of syntax to it, if there is some sort of deterministic way of
verifying it, that's the name of the game.
19:14.087 -->
19:20.567
Essentially, even Anthropic's own best practices says the best way you can use a coding
agent is to give it verifiable intent.
19:20.567 --> 19:22.407
That's the last word on it.
19:22.584 --> 19:26.001
so into your point, you intent-driven development, right?
19:26.001 --> 19:27.855
Like that's like what you're all about.
19:27.855 --> 19:29.488
Does OpenSpec take that forward?
19:29.488 --> 19:32.233
Like what do you say an intent looks like?
19:32.301 --> 19:32.561
yeah.
19:32.561 --> 19:35.135
So the way OpenSpec does it is quite interesting.
19:35.135 --> 19:36.796
Hope that's visible.
19:36.938 --> 19:46.998
Okay, so this I'm sure we can recall the swim lane diagram from a little earlier about
spec driven development, how we had the design discover and all of those faces right now
19:46.998 --> 19:50.818
spec driven development with open spec follows a three phase approach.
19:50.818 --> 19:52.609
It's got largely three commands.
19:52.609 --> 19:56.740
You propose a change, you apply that change and then you archive that change.
19:56.740 --> 19:56.960
Right.
19:56.960 --> 20:02.502
So proposal is where you go through creating the various artifacts like user stories,
acceptance criteria, if you will.
20:02.502 --> 20:04.982
And from there you create the tasks and whatnot.
20:04.982 --> 20:05.942
And then eventually
20:05.942 --> 20:08.631
you review those artifacts, like that's the first step.
20:08.631 --> 20:17.266
what's happening here and then once you're good to go you're happy with the intent that
has been articulated in this artifacts then you apply the change which is where the tasks
20:17.266 --> 20:21.860
are executed by the agent which ends up creating the implementation which is your code
itself.
20:21.860 --> 20:22.881
That's apply.
20:22.881 --> 20:30.586
Once you build this out then eventually what you do is this most interesting phase of this
tool which is when you archive it it goes into two places.
20:30.586 --> 20:34.999
This spec which is a chain spec initially starts out as a delta.
20:34.999 --> 20:36.423
What I mean by a delta
20:36.423 --> 20:38.147
as every spec says.
20:38.147 --> 20:47.412
the feature which is being added as part of this change is modifying such and such from an
existing code base, it's deleting such and such from existing code and it's adding this,
20:47.412 --> 20:48.212
et cetera.
20:48.212 --> 20:51.875
So because it's a Delta format, I can sort of treat it like a ledger, right?
20:51.875 --> 20:56.398
I can start attaching this Delta on top of each other and create a source of truth.
20:56.398 --> 21:03.083
So what happens is when I archive, it bundles this up and creates a top level source of
truth specification, right?
21:03.083 --> 21:06.264
And that source of truth specification is representative of my
21:06.264 --> 21:13.505
current state of the application and it archives the rest of course that you saw earlier
which I was just showing you.
21:13.505 --> 21:23.905
This is very unique to OpenSpec when compared to let's say spec kit or keyrow because they
have a ledger not really a ledger they have a record of what all happened you still have
21:23.905 --> 21:31.076
independent folders for each feature but then there is no world view or top level view of
what's going on and
21:31.076 --> 21:40.608
The natural problem with that sort of stacking things is when I create feature number 10,
it's possible that I knocked off feature two as part of feature 10.
21:40.608 --> 21:50.266
So if I actually take the entirety of the spec and say, is this valid today, even at a
conceptual level, that's not true because I don't have a worldview of what's going on.
21:50.266 --> 21:57.862
this source of truth spec is the unique piece of open spec which kind of lends itself to
Birgitta's spec anchored, so to speak.
21:57.912 --> 22:00.203
interpretation of how I looking at it.
22:00.203 --> 22:03.210
Right, but you're not claiming spec as source.
22:03.210 --> 22:04.733
What's the limit there?
22:04.733 --> 22:07.526
You're saying the code is still an important, yeah.
22:07.526 --> 22:10.298
standard should be it's 100 % verifiable, right?
22:10.298 --> 22:15.751
I should be able to, let's say, go do some mischief in the code and unintentionally
modify.
22:15.751 --> 22:18.184
Let's say I'm a new engineer on the project.
22:18.184 --> 22:21.145
You've been using ah SDD tools for some time.
22:21.145 --> 22:24.987
I do not go through that route of using spec of source.
22:24.987 --> 22:27.929
I actually modify the code for whatever reason.
22:27.929 --> 22:30.671
And the system should stop me from doing that, right?
22:30.671 --> 22:32.272
Like it should say, hey, you're broken spec.
22:32.272 --> 22:34.844
That I haven't been able to fully get.
22:34.844 --> 22:40.011
I have a duct tape solution for it, but I won't say I have a fully functioning solution
yet.
22:40.011 --> 22:42.173
And that's one part which is pending.
22:42.465 --> 22:51.293
Okay, it is not someone you're not saying that you couldn't use open spec to work in a
spec as source way You're saying you don't have any guardrails in place in open spec to
22:51.293 --> 22:53.186
force a spec as source approach.
22:53.186 --> 22:53.999
Do I have that right?
22:53.999 --> 22:54.689
That is correct.
22:54.689 --> 22:56.290
I don't think we have today.
22:56.290 --> 22:57.491
How do I put it?
22:57.491 --> 23:00.963
It depends on the specification format and what you're using, right?
23:00.963 --> 23:05.847
So the open spec itself does not limit you from making it spec as source.
23:05.847 --> 23:08.448
It gives you all the basic fundamentals, right?
23:08.448 --> 23:19.075
But then if the specification format you choose or the amount of detail you choose to put
into it is weak, then the verifiability of intent is also weak, which means, it's like
23:19.075 --> 23:21.226
having a test with weak assert statements
23:21.226 --> 23:26.837
right, then it's obviously going to have
like loopholes to, you know, game the system.
23:26.909 --> 23:34.834
Well, and that's another question I had When you said earlier that, implement tasks and
that's the code, I thought to myself, well, yeah, I'm also the test Does OpenSpec have an
23:34.834 --> 23:36.756
opinion on how tests are generated?
23:36.756 --> 23:42.411
that hidden in this diagram and it's always just a tier one in one of these boxes, or is
it outside of this flow?
23:42.455 --> 23:46.817
So whether we use how we generate tests and what all of that right.
23:46.817 --> 23:50.700
Most of the spec driven development tools some of them are very opinionated about it.
23:50.700 --> 23:57.656
OpenSpec doesn't really say you have to write it in a certain way right but you could
choose to do whatever makes meaningful sense.
23:57.656 --> 24:05.651
For example I use Gherkin syntax to define my acceptance criteria and I directly translate
Gherkin into my acceptance test.
24:05.651 --> 24:08.072
So that way I can do ATDD on my
24:08.072 --> 24:10.603
application to build out the application.
24:10.603 --> 24:14.594
Speckit simply says in the constitution that if you follow TDD, right?
24:14.594 --> 24:19.734
But that doesn't necessarily mean that like what sort of tests are you writing?
24:19.734 --> 24:23.125
Are you writing an outside in test or an inside out sort of test?
24:23.125 --> 24:24.926
All of that is very nebulous.
24:26.126 --> 24:33.578
sort of it depends answer to your question is that these tools, they give you the
wherewithal to do what you need to.
24:33.578 --> 24:35.499
But then the software engineering surface
24:35.499 --> 24:37.841
is something that we need to apply on top of it.
24:37.841 --> 24:38.643
Yeah, okay.
24:38.643 --> 24:41.164
Okay, so we should define some terms.
24:41.164 --> 24:42.125
We're going fast.
24:42.125 --> 24:52.611
Gherkin, when people say that, I think of the, it was associated with behavior-driven
development or driven design, given when then, given someone has clicked on this button,
24:52.611 --> 25:01.066
when their account balance is below 50, then, you know, something, something, something
is, it's a way to be very specific and not just sort of, as a user, I'd like to be able to
25:01.066 --> 25:05.268
money, but more like, no, no, when this happens, this is exactly what should follow.
25:05.268 --> 25:06.488
Am I remembering right?
25:06.488 --> 25:13.568
And how does that compare to, you also used the phrase ATDD, which I think is acceptance
test.
25:13.728 --> 25:14.408
Yeah, yeah, yeah.
25:14.408 --> 25:15.878
So can you get into that for a minute?
25:15.878 --> 25:16.438
Absolutely.
25:16.438 --> 25:20.780
So let me just break down one of the features that are showing you earlier.
25:20.780 --> 25:26.804
So let's say ah I'm trying to fix the SEO on my website here and this is how my spec
looks.
25:26.804 --> 25:29.606
here's the given when then which you actually called out.
25:29.606 --> 25:32.888
So my markdown file,
I'm not really getting into a feature file here.
25:32.888 --> 25:41.466
Technically speaking, gherkin would mean dot feature that also I do at times, but I have
like clear given when then which means this translates well into a test case.
25:41.466 --> 25:41.767
Right.
25:41.767 --> 25:43.157
These are acceptance
25:43.940 --> 25:44.358
Mm-hmm.
25:44.358 --> 25:53.195
the point of view of what does the business want like in this case what I want from the
website and uh now this acceptance criteria can be directly translated into an acceptance
25:53.195 --> 26:05.229
test which means that defines the done criteria for the feature itself once Claude code or
codec CLI has built it what I mean by that is this usually translates into a playwright uh
26:05.229 --> 26:10.053
sort of test case maybe I don't even have to write the test these days because it's a CLI
right so
26:10.053 --> 26:19.531
I'm able to invoke it using an agentic way of doing it just a tool call and execute and
test it out So once the code is built literally I have one more agent which is a quality
26:19.531 --> 26:25.305
agent which goes through this acceptance criteria And starts checking it off like hey is
this acceptance criteria done?
26:25.305 --> 26:25.715
Is it done?
26:25.715 --> 26:26.105
Is it done?
26:26.105 --> 26:26.714
Is it done?
26:26.714 --> 26:36.595
So it's kind of doing that testing and that's what I mean by saying One is this drives
whether The design itself like how it's done and then post facto once the code is built.
26:36.595 --> 26:37.626
This is also the way
26:37.626 --> 26:41.519
for me to verify whether it is actually done, done, so to speak.
26:41.519 --> 26:43.701
So that's how I'm driving it.
26:43.701 --> 26:48.526
So one, yes, ATDD is driving the overall direction for the code.
26:48.526 --> 26:55.852
And then there is test-driven development happening at the unit level, like functions and
stuff, the whatever React code that is being written.
26:55.852 --> 26:59.736
That is, again, going through ATDD process, but that's an independent engineering surface.
26:59.736 --> 27:05.331
But this engineering surface is for me to keep the implementation in line with my intent.
27:05.331 --> 27:08.475
So we're not opinionated We allow for flexibility there.
27:08.475 --> 27:10.448
OK, Hari this is cool.
27:10.448 --> 27:12.509
Thank you for walking us through this a little bit.
27:12.509 --> 27:15.471
You're opening my eyes And you're showing me stuff that I'm interested to try.
27:15.471 --> 27:20.694
Maybe I'll have to do an article about that at some point uh where we get into it.
27:20.795 --> 27:22.216
we have some time remaining.
27:22.216 --> 27:24.609
We've spent a fair amount on this, which is good.
27:24.609 --> 27:29.042
But yeah, let's get into some of uh the questions that we ask all of our guests.
27:29.042 --> 27:31.113
You've talked a little bit about the tools you're building.
27:31.113 --> 27:32.943
You've talked a little bit about the tools you're using.
27:32.943 --> 27:33.955
You mentioned Vim.
27:33.955 --> 27:35.476
You mentioned all the different models.
27:35.476 --> 27:36.937
What's your go-to right now?
27:36.937 --> 27:40.350
I'm going to assume Vim, but what's your go-to approach?
27:40.350 --> 27:43.801
Are you literally going back and forth between the different models all day every day?
27:43.801 --> 27:45.729
Or is that just a feature you strive for?
27:45.729 --> 27:47.645
How are you using these tools?
27:47.645 --> 27:52.247
for me the go-to tools are Cloud Code, Open Code and Codec CLI.
27:52.247 --> 27:56.370
These are my coding agents, essential bread and butter sort of tools.
27:56.370 --> 28:04.014
Within these, I obviously wire up all the different models because I like one model to
opine on another model's work.
28:04.014 --> 28:08.270
So that way I get more reasonable outcomes, so to speak.
28:08.270 --> 28:11.863
it's more anecdotal and based on experience, because I find GPT high
28:11.863 --> 28:23.022
reasoning sometimes and and Claude being the best programmer So these are things which I
use and obviously my tooling landscape also involves a ton of LSP servers for all
28:23.022 --> 28:36.753
independent languages and I have reduced my usage of MCP because again being context
window sensitive because MCP servers are fairly annoying so I use a lot of CLI tools like
28:36.753 --> 28:38.344
I use repo mix a lot to
28:38.344 --> 28:44.638
reduce the context window because it can pack your code into meaningful bite-sized chunks.
28:44.638 --> 28:55.046
yeah my go-to tools every day are largely the coding agents I mentioned and all the models
I do whip through all of them and in some of the cases the clients that I work with they
28:55.046 --> 29:06.313
cannot afford to have an external model they have a local LLM which they have to run
because for technical and also for security reasons so yeah because and so for that
29:06.313 --> 29:16.220
reason like you know having the flexibility to switch models is always an important aspect
of the daily workflow for me and oh sandboxes are a big part of my workflow because I
29:16.220 --> 29:26.758
don't want to constantly give permissions but I also am paranoid of giving permissions to
all these agents so I do have sandboxes for everything so I can sort of have that
29:26.758 --> 29:33.484
compartmentalization of you know I can have this run dangerously without permissions
within that sandbox
29:33.484 --> 29:38.084
Yeah, yeah, I noticed a vendor, a cloud vendor that I actually do use the other day.
29:38.084 --> 29:45.908
was saying, we'll give you ephemeral environments that you can let it have all the
permissions on so it doesn't have to be your actual computer.
29:45.908 --> 29:49.288
And I thought, oh yeah, I can definitely see the value in that.
29:49.288 --> 29:51.959
Of course, it would be nicer if you're not even paying for it by the minute.
29:51.959 --> 29:52.720
Okay, interesting.
29:52.720 -->
29:54.193
We talked about some guardrails already.
29:54.193 --> 29:55.934
You talked about sandboxes.
29:55.934 --> 29:58.187
I think you mentioned something called repo mix.
29:58.187 --> 30:01.441
And I think you said that it's like a context window helper.
30:01.441 --> 30:03.633
It makes your code smaller, I think.
30:03.633 --> 30:05.756
Can you talk more about that?
30:05.756 --> 30:06.811
Or other guardrails.
30:06.811 --> 30:07.152
Yeah.
30:07.152 --> 30:09.115
yeah, mean, a REPL mix.
30:09.115 --> 30:12.987
oversimplifying what it does, at least there are a bunch of tools like RepoMix.
30:12.987 --> 30:22.581
Basically, there is a bunch of context that gets used up in navigating your code base and
getting all of that and then reading it using file tools and whatnot.
30:22.581 --> 30:30.721
So simple way of doing that is you pack all your code into a single file, so to speak, and
then you ship it if you want to to the context window so it doesn't have to go back and
30:30.721 --> 30:33.312
forth, back and forth, and waste a ton of tokens.
30:33.312 --> 30:37.247
Again, the mileage you get out of such tools varies from code
30:37.247 --> 30:38.378
agent to agent.
30:38.378 --> 30:46.884
Some agents are intrinsically more optimized not to waste tokens for navigation, but
others are not so much.
30:46.884 --> 30:54.329
So I kind of invariably end up using tools like this to say, pack all the files within
this particular folder, ship it for me.
30:54.329 --> 31:00.292
So it just puts it into a simple XML file and without having to go into the directory
structure of it.
31:00.292 --> 31:06.159
And yeah, again, these are some of the things which I use sparingly where I am dealing
with
31:06.159 --> 31:08.852
like Brownfield largely because it's existing code.
31:08.852 --> 31:13.456
I do not want to say like, know, go read my three million lines of code and then tell me
what to do.
31:13.456 --> 31:16.479
That's wouldn't be a wise place to do it.
31:16.479 --> 31:19.547
So yeah, so that's where this tools come into picture.
31:19.547 --> 31:20.268
I see, I see.
31:20.268 --> 31:29.626
So on the face of it then, it's not so much that they're reducing the number, they're not
like literally taking a wordy Python approach and slimming it down through sort of
31:29.626 --> 31:32.598
compression techniques, one-liner tricks and party tricks like that.
31:32.598 --> 31:34.509
It's, yeah.
31:34.509 --> 31:37.952
don't know or haven't really pushed them to the limit there.
31:37.952 --> 31:40.163
I'm sure there are more intelligent mechanisms.
31:40.163 --> 31:43.837
I'm thinking even RepoMix actually does a lot more than what I'm giving it credit for.
31:43.837 --> 31:48.633
But that's like at least at its simplest form, are reducing the nonsense.
31:48.633 --> 31:55.081
So it may not be saving context tokens in terms of the literal tokens in the code, but
it's more the navigation because it's all in one file.
31:55.081 --> 31:57.274
It doesn't have to remember how to get from here to there.
31:57.274 --> 31:58.195
OK, got it.
31:58.195 --> 31:58.807
Nice.
31:58.807 --> 31:59.249
Cool.
31:59.249 --> 32:02.544
Any superpowers that these tools have that you were surprised by?
32:02.544 --> 32:03.335
yeah, OK.
32:03.335 --> 32:13.381
So I think the most recent ones, which I'm really, really happy about, especially the
front-end design capabilities that I got with Claude Cote, has been really...
32:13.381 --> 32:17.825
I'm good at saying what looks aesthetically good, what is bad, right?
32:17.825 --> 32:21.817
But I'm really bad at translating that into actual look and feel.
32:21.817 --> 32:24.340
And I have the difficulty even with having a designer.
32:24.340 --> 32:27.411
My designers always give me uh grief because...
32:27.411 --> 32:29.342
I'm not good at articulating that.
32:29.342 --> 32:33.762
using the design plugin in Cloud Code has been a boon.
32:33.762 --> 32:42.032
And then I think even the more recent capabilities that have come into, let's say, Figma
or even Cloud Design, where you can chat your design.
32:42.032 --> 32:44.033
Again, it's not the most optimal, I would say.
32:44.033 --> 32:49.033
There is still component libraries and other things that still need to be taken care of.
32:49.033 --> 32:55.265
It's not a solved problem, but it has certainly gotten me from, let's say, 10%, 20 % to
about 60%, 70%.
32:55.265 --> 32:58.456
So that's a big, big win for me, at least personally.
32:58.456 --> 33:03.668
I'm still surprised at how is at that, creating really nice, consistent UI.
33:03.668 --> 33:13.770
If I can define what my design system is once, and then I can have artifacts, like even
flyers and slide decks and everything created from one design system, that's been
33:13.770 --> 33:14.361
brilliant.
33:14.361 --> 33:15.472
I love it.
33:15.472 --> 33:18.463
My designers also like it because they don't have to deal with me now.
33:18.463 --> 33:19.983
This is a better way of
33:19.983 --> 33:20.945
doing it.
33:20.974 --> 33:22.537
Awesome, awesome, love it.
33:22.537 --> 33:24.340
Okay, cool.
33:24.340 --> 33:26.815
So what about teams that you observe?
33:26.815 --> 33:34.140
We talked earlier about your role as CEO at Polarizer, helping enterprises adopt AI
augmented development practices and so on.
33:34.140 --> 33:39.755
Are there markers for a team that's doing well versus markers for a team that's
struggling?
33:39.755 --> 33:41.487
What sorts of processes are you seeing there?
33:41.487 --> 33:43.098
That's a brilliant question.
33:43.098 --> 33:53.824
think that's kind of the crux of my article which we initially started off with, I think
the biggest marker is not about technical capability or even to that matter, their AI
33:53.824 --> 33:55.195
chops, so to speak, right?
33:55.195 --> 33:59.098
The biggest marker I see is, they recognize how big of a shift it is?
33:59.098 --> 34:02.810
And do they recognize the cultural aspect of it, right?
34:02.810 -->
34:07.304
One is, using an AI coding agent is not about inculcating a developer
34:07.304 --> 34:10.136
a tool into your daily practice.
34:10.136 --> 34:16.750
That's not at all it because that would mean independent developer productivity is boosted
and you get some certain percentage of it.
34:16.750 --> 34:17.341
Right.
34:17.341 --> 34:25.876
This is a complete SDLC shift like how the current system is a human centric workflow for
building software systems.
34:25.876 --> 34:26.407
Right.
34:26.407 --> 34:28.378
It is wired around our speed of development.
34:28.378 --> 34:31.230
It is wired around our speed of verification.
34:31.230 --> 34:36.343
It's not built for the compressed timelines that we're dealing with with an AI coding
agent.
34:36.343 --> 34:36.575
Right.
34:36.575 --> 34:47.093
oh if the team is recognizing the shift and they realize that it's more about intent
articulation, it's not about like preserving the existing structure, you know, I have a
34:47.093 --> 34:52.248
dev, have QA teams, I have this, and this is the sequence in which it will always work.
34:52.248 --> 34:55.381
We want to locally deploy AI agentic workflows there.
34:55.381 --> 34:58.714
Sure, you will get tactical advantages.
34:58.714 --> 35:03.319
I'm not denying that and I'm seeing teams getting it, but you really want to push the
envelope.
35:03.319 --> 35:05.506
You've got to think about it as a cultural shift.
35:05.506 --> 35:07.189
You are hiring.
35:07.201 --> 35:14.835
people onto the team is how you should think about it when you're getting a coding agent
into that equation because it takes your attention.
35:14.835 --> 35:17.657
It takes your effort.
35:17.657 --> 35:25.041
So how much thought we put into hiring someone and have them come up to speed and build
stuff for us.
35:25.041 --> 35:28.122
That's exactly the kind of thought process that goes in.
35:28.662 --> 35:30.283
So yeah, that's the biggest marker for me.
35:30.283 --> 35:35.206
um It's not even like, you know, whether they know how to use all the interesting
35:35.206 --> 35:38.326
interesting features in Cloud Code, agent teams, sub agents, all that.
35:38.326 --> 35:46.163
But it's just your thought process of, I get my intent across as an individual and as a
group ah to this system?
35:46.190 --> 35:46.981
I love what you're saying.
35:46.981 --> 35:57.912
And what's coming up for me when you say that, I think for those of us, and that's maybe
still me right now, that are using this as an amplifier for individual productivity, we
35:57.912 --> 36:02.125
sort of hit a bit of a wall at the PR level pretty often.
36:02.125 --> 36:03.906
It's like, OK, it can go really fast.
36:03.906 --> 36:04.967
Isn't that cool?
36:04.967 --> 36:06.389
But now what?
36:06.389 --> 36:11.343
And I think some teams are sort of trying to say, well, we have a really good
36:11.343 --> 36:17.746
test suite and so like maybe the PR side isn't as important somehow and that seems like
maybe it'll work.
36:17.746 --> 36:25.962
it seems like with OpenSpec and some of the stuff that you're doing, there's maybe a
second possibility that if you have this really good system of intent tracking, this
36:25.962 --> 36:31.854
really good system of understanding what the system should be, well then maybe you can
trust it to give PRs.
36:31.854 --> 36:35.097
Like right now if you ask an agent to give you a
36:35.097 --> 36:37.277
pull a request review on almost any code.
36:37.277 --> 36:40.908
It can write you pages about what's wrong, and maybe some of it's kind of important.
36:40.908 --> 36:46.590
And maybe there's a gem in there that's really important, but some of it's just, I don't
know, like, it's just talking.
36:46.590 --> 36:48.252
It's like, that doesn't really matter.
36:48.252 --> 36:56.152
But with the intent-driven tools that you're talking about, like, maybe that gets us a
little bit further, or am I, I don't know, maybe I'm being aggrandizing there.
36:56.152 --> 36:56.863
What do you think?
36:56.863 --> 37:05.754
No, I think you're absolutely on point there in terms of the concept you are going
towards, if I'm not wrong, is actually very close to this thing which has recently become
37:05.754 --> 37:13.727
popular called software dark factories, where like, know, your agents don't sleep at
night, they're available to 24 seven.
37:13.727 --> 37:18.838
So why have them like, you know, why do we have to stay glued to the screen when they can
build the code?
37:18.838 --> 37:25.103
So what we are trying to do is put a system in place, which can then have this agent go
and build
37:25.103 --> 37:25.994
tools off of.
37:25.994 --> 37:34.039
Now the important piece here to understand is that if I see a bug, the temptation is to go
fix that bug in the code, right?
37:34.039 --> 37:41.905
But the bug is a symptom of something missing in the specification, or it's probably a
symptom of something missing in the intent articulation phase.
37:41.905 --> 37:42.485
Yeah.
37:42.485 --> 37:44.567
So that's what we want to get into, right?
37:44.567 --> 37:47.470
if I may again take one moment to share my screen,
37:47.470 --> 37:49.111
It is quite a read this article.
37:49.111 --> 37:51.642
apologize if it's quite long.
37:51.642 --> 37:55.304
yeah, so I think what I'm trying to get to is this setup, right?
37:55.304 --> 38:01.537
Like if there is a gap in the overall implementation, it could signal an issue in the
implementation itself.
38:01.537 --> 38:04.548
And that's an easy fix, which is where the tests and stuff come in.
38:04.548 --> 38:09.060
Like, you know, they catch an issue, they fix it and yeah, you go back to a better
implementation.
38:09.060 --> 38:17.004
But it could also mean that there is something lacking in your specification, which is you
have not been articulate enough in your communication of intent.
38:17.004 --> 38:18.315
could be an issue here.
38:18.315 --> 38:19.466
And why is that?
38:19.466 --> 38:25.670
Potentially because the conversations we had with the AI or with each other did not elicit
that intent very well.
38:25.670 --> 38:32.164
Maybe it needs like, you we need to talk about accessibility more explicitly rather than
like, you know, we forgot about it, right?
38:32.164 --> 38:39.379
So the next time we go through the process of creating a user story, it has to pop up that
question to say, have you thought about accessibility?
38:39.379 --> 38:42.761
And that's where the hardness feedback comes into picture.
38:42.941 --> 38:45.643
And the entire SDD workflow itself could be modified.
38:45.643 --> 38:47.224
That could be the feedback to that.
38:47.224 --> 38:58.903
So essentially what you're looking at is if you have a system in place that can generate
software ah and progressively you can keep on improving it over a period of time.
38:58.903 --> 39:09.891
ah You will get to that state which you're calling out Kyle which is eventually the
software factory where our jobs is largely to ideate and articulate intent and this agent
39:09.891 --> 39:14.584
or the job of the agents to execute on the stuff that we have put out.
39:14.584 --> 39:16.666
So that's how I'm looking at it.
39:16.666 --> 39:18.558
Okay, I think I get this.
39:18.558 --> 39:25.361
What's instinctive to me about what I'm looking at is you're talking about like, you know,
there's feedback for the process.
39:25.361 --> 39:27.102
There's feedback for the specification.
39:27.102 --> 39:32.684
Like instead of fixing the code, like how do you fix the system so that the code is
correct next time?
39:32.684 --> 39:34.264
I'm with you on all of that.
39:34.345 --> 39:40.405
When you get into dark factory, to me it brings up, there's a little bit of a debate right
now is this more like a waterfall style approach?
39:40.405 --> 39:41.336
how does this look then?
39:41.336 --> 39:48.741
Like the humans are just spending our time writing these specs and having these
conversations that get these intents to be recorded.
39:48.741 --> 39:53.274
And then like what, we push a button and overnight they go and make the thing.
39:53.274 --> 40:02.380
Okay, sometimes, sometimes in software development we do have just sort of a big pile of
work that either can be well understood or already is well understood.
40:02.380 --> 40:04.827
And it just needs to be written down.
40:04.827 --> 40:10.642
You know, and then that writing needs to be self-checked for internal cohesion and
consistency.
40:10.642 --> 40:16.888
And then, you know, we can actually have fairly high confidence that, if the robot build
this overnight, it will be a good thing.
40:16.888 --> 40:18.369
There's work like that, right?
40:18.369 --> 40:23.813
And there's some question even there that like, are you really sure that the spec was
right?
40:23.813 --> 40:28.058
If you're not there with the dark factory while it's building, you might still miss
things.
40:28.058 --> 40:29.779
But let's set that aside.
40:30.304 --> 40:32.657
Not
every problem is so knowable.
40:32.657 --> 40:33.138
Right?
40:33.138 --> 40:39.338
I'm sometimes surprised by when I actually need discovery and when I don't.
40:39.338 --> 40:42.338
Sometimes I think when I'm sitting down with Claude, like, oh, I know what I need.
40:42.338 --> 40:43.398
I just need to describe it to him.
40:43.398 --> 40:47.769
And then I see it online later and I'm like, oh, that's not what I meant.
40:47.769 --> 40:50.040
Or that's what I said, but I'm wrong.
40:50.040 --> 40:50.640
Right?
40:50.640 --> 40:57.051
And so discovery and learning for us, the writers of the intent, I think is an important
part of the creative process.
40:57.051 --> 40:58.982
And sometimes, you know, you you'd be...
40:58.982 --> 41:05.107
How many times have you worked with a designer or an experienced designer and you
implemented the way they ask and then they look at it they're like, oh, right, this is
41:05.107 --> 41:07.459
actually gonna be better this way, right?
41:07.459 --> 41:10.092
Interactions can change meaning, can change context.
41:10.092 --> 41:16.029
So when I think about these dark factories, there's this whole debate around is spec
driven actually good or are we going back to waterfall?
41:16.029 --> 41:19.413
But to me, what's more interesting is this, aren't we losing something?
41:19.413 --> 41:21.174
Just like when you outsource,
41:21.275 --> 41:29.943
We used to talk about like if business outsources a really critical function in a way
where they lose access to what's happening as part of the process of doing that function,
41:29.943 --> 41:33.665
the business itself becomes sort of poorer for it and less understanding.
41:33.665 --> 41:37.759
If you outsource in a way that you retain that knowledge, you're in a better shape.
41:37.759 --> 41:40.955
So these dark factories, I don't know, are they the right approach?
41:40.955 --> 41:41.714
Like what do you think?
41:41.714 --> 41:44.434
See, I think uh the dark factory as a concept.
41:44.434 --> 41:50.097
ah I kind of look at it as something to aspire to in terms of what is the possibility,
right?
41:50.097 --> 41:52.779
Whether I want to get there is a different question.
41:52.779 --> 42:00.343
But if I can reach for the moon, then like, you know, say like 80 % of it is probably
still very practical and pragmatic point of view.
42:00.343 --> 42:05.526
That is one, like from the point of view of whether how much hype there is versus what is
reality.
42:05.526 --> 42:11.609
I still think it's a very good goal to aim towards, but how far you want to get along that
as a personal choice.
42:11.609 --> 42:13.811
and independent setup.
42:13.811 --> 42:18.053
The second point which you actually hit is very important is isn't this waterfall?
42:18.053 --> 42:26.949
Isn't it like we are having to force ourselves to think ahead of time every single detail
so that this thing can build at night otherwise I'm going to be waking up in the morning
42:26.949 --> 42:29.501
to something that is not what I wanted.
42:29.841 --> 42:37.489
So the reality of spec driven development honestly is I think it doesn't have to be looked
at as once I write the spec there's no way back for me.
42:37.489 --> 42:38.870
That's not really true.
42:38.870 --> 42:39.711
Just like how we
42:39.711 --> 42:43.293
I think even Ken Beck had recently posted on LinkedIn.
42:43.293 --> 42:48.146
In TDD, the whole joy of the process is I write a test, I build implementation.
42:48.146 --> 42:49.447
the process, I learn something.
42:49.447 --> 42:52.659
I go back and fix the test and I go back and write the code again.
42:52.659 --> 42:57.713
So this test feeding into the code and the code feeding back into the test, there's a
learning going on here.
42:57.713 --> 43:00.815
And I look at it exactly like that with spec driven development.
43:00.815 --> 43:02.877
More often than not, I get the spec wrong.
43:02.877 --> 43:06.339
And it's not like I'm getting it right in very first shot.
43:06.339 --> 43:08.080
And my features are not like I'm
43:08.080 --> 43:10.702
specifying the entire application all at once.
43:10.702 --> 43:13.904
So like I showed you earlier, I'm building small little features.
43:13.904 --> 43:14.925
I'm lining it up.
43:14.925 --> 43:18.507
Maybe the first time not even sure if I've articulated enough very well.
43:18.507 --> 43:20.248
So I'll actually build it out, right?
43:20.248 --> 43:21.489
To see how it looks.
43:21.489 --> 43:24.351
And then if it's not what I want, I'll throw away the code.
43:24.351 --> 43:25.672
I'll go back to the spec.
43:25.672 --> 43:26.412
I'll fix it.
43:26.412 --> 43:28.614
I'll go back and forth a little bit.
43:28.614 --> 43:31.657
I can afford to do this a lot because what am I losing?
43:31.657 --> 43:34.548
My build time is hardly five minutes to 10 minutes.
43:34.630 --> 43:37.133
So I've gained so much time during the build that
43:37.133 --> 43:39.614
I don't need to be stingy with how I plan, right?
43:39.614 --> 43:42.025
So I can try multiple things.
43:42.025 --> 43:51.901
can even have like the same feature built two, three different ways and then learn from it
before I actually say, okay, now I'm happy with the spec, let's build it, go into
43:51.901 --> 43:55.003
regression testing and whatnot and verify it.
43:55.003 --> 43:55.645
So.
43:55.645 --> 44:02.431
Well, and I think part of what excited me about OpenSpec when you were showing it just now
is I could imagine it being iterative.
44:02.431 --> 44:12.391
could imagine being, you start out today and I think your acceptance criteria was
basically SEO, when they're looking at the services page and the web crawler comes.
44:12.391 --> 44:20.509
I can imagine it being like, okay, tomorrow we realize, I kind of want something different
and that there's a process for taking that new different thing and
44:20.509 --> 44:23.971
going and applying that concept to the past.
44:23.971 --> 44:28.133
So there's still a process for
iteration there and maybe even simplifying that iteration.
44:28.133 --> 44:30.544
So I think that's part of what I was attracted to about what I was seeing.
44:30.544 --> 44:32.474
Because it is that iteration.
44:32.474 --> 44:33.495
That's the important bit.
44:33.495 --> 44:36.256
I'm not sure I need to iterate on every for loop.
44:36.256 --> 44:38.397
Well, for loops are iterative, ha.
44:38.397 --> 44:42.369
But getting the parenthesis right, I don't think I care about iterating over that.
44:42.369 --> 44:44.651
But iterating over the spec, I care a lot about.
44:44.651 --> 44:47.693
So yeah, to me, Dark Factory sounds like you're losing some of
44:47.693 --> 44:49.336
And maybe, maybe just a praise.
44:49.336 --> 44:49.870
I don't know.
44:49.870 --> 44:52.021
I think a dark factory is like this, right?
44:52.021 --> 45:00.515
If you really want to go down the factory analogy, even industrial production goes through
prototypes and then actual user products.
45:00.515 --> 45:05.758
I'm not going to ship my prototype car model to a person, right?
45:05.758 --> 45:07.538
I have multiple iterations of that.
45:07.538 --> 45:10.320
I have multiple iterations of my assembly line itself.
45:10.320 --> 45:13.241
But what I'm shipping is something that I'm really sure of.
45:13.241 --> 45:17.243
And all our software essentially is a mix of different types of features.
45:17.243 --> 45:19.724
Some are more dull and boring.
45:19.724 --> 45:25.069
and rinse and repeat sort of features, versus others are a little bit more requires
thought process.
45:25.069 --> 45:28.872
And like you rightly put it, we cannot afford to outsource thinking.
45:28.872 --> 45:31.253
We can afford to outsource execution.
45:31.253 --> 45:39.461
And the concept of factory for me is to keep thinking to ourselves so that we can think
through some of the more complex features, keep the joy of building more challenging
45:39.461 --> 45:40.642
features to us.
45:40.642 --> 45:48.289
And while there is run of the mill features which we have to keep doing, and that's where
we could take help from the agent to get that job done for us.
45:48.289 --> 45:50.001
So it's a platter, right?
45:50.001 --> 45:53.007
It's not like one size fits all for all features.
45:53.007 --> 45:55.559
Yeah, yeah, okay, cool, cool.
45:55.559 --> 46:04.685
touched a little bit on how all this changes product management quite a lot about how this
approach and your, not just your approach, but your...
46:04.685 --> 46:09.608
implementation of that approach, OpenSpec, on how it's opinionated about product
management and story breakdown.
46:10.049 --> 46:12.260
We've talked a little bit about architectural planning.
46:12.260 --> 46:16.066
We've talked about software development itself, about testing, integration.
46:16.066 --> 46:21.261
when you think about how generative AI tooling is changing deployment, what are you seeing
out there right
46:21.261 --> 46:22.482
It's a great point.
46:22.482 --> 46:29.585
And in fact, that harks back to what we discussed in the beginning, And spec driven
development are more structured dialogue.
46:29.585 --> 46:33.427
You're separating the business from the technology, and then you're building it out.
46:33.427 --> 46:39.531
So which means when you separate the business, the what is a separate document, and then
there are various engineering surfaces you're applying to it.
46:39.531 --> 46:44.434
One is technically architecture, which kind of defines your repository structure.
46:44.434 --> 46:45.894
What is the tech stack and whatnot?
46:45.894 --> 46:47.355
Second is your deployment.
46:47.355 --> 46:49.676
Now I can say that, hey, I am going
46:49.676 --> 46:58.622
to deploy my applications in such and such a way, which means that is what decides my Helm
charts, my Kubernetes structure and where this application needs to go.
46:58.622 --> 47:01.925
There could be one more layer which is a security aspect to it.
47:01.925 --> 47:07.228
So that applies the brings in the layer of, you know, what is the compliance that I'm
looking at?
47:07.228 --> 47:11.473
What sort of, you know, SBOM that I'm supposed to be compliant with.
47:11.473 --> 47:15.476
So those are all things which start feeding into layer by layer detailing.
47:15.476 --> 47:17.597
And then all of this put together goes into
47:17.597 --> 47:19.479
that task list eventually.
47:19.479 --> 47:21.881
And the task list is the execution surface, right?
47:21.881 --> 47:29.488
And the execution surface then is able to generate artifacts, not just of the code itself,
but it's also generating deployment artifacts.
47:29.488 --> 47:31.493
It's generating security.
47:31.493 --> 47:32.825
adjustments and so on.
47:32.825 --> 47:43.158
So what it's doing is all the roles that we have, we can then generate skills or agents
out of it, which can then opine on the feature that's being built and eventually
47:43.158 --> 47:46.860
contribute to long list of things that need to be done by the agent.
47:46.860 --> 47:49.153
And that's the control surface for me.
47:49.153 --> 47:50.373
Great, okay, cool.
47:50.373 --> 47:53.804
And in there you ended up touching on not just deployment, but infrastructure.
47:53.804 --> 47:55.771
And you talked about dependency management.
47:55.771 --> 48:00.993
SBOM, your software bill of materials, I guess that's where you're thinking about what
libraries you're allowed to use and not.
48:00.993 --> 48:01.773
Go ahead.
48:02.352 --> 48:03.183
Yeah, yeah, okay.
48:03.183 --> 48:07.874
here's a question that I've personally been wrestling with a little bit.
48:07.874 --> 48:09.794
What do you think happens to pair programming?
48:09.794 --> 48:12.326
What do you think happens to mob programming with all of this stuff?
48:12.326 --> 48:13.042
yeah, so...
48:13.042 --> 48:22.168
Pair programming was largely about uh framing and then solving between two of us and we
could exercise different muscles and we could go on for some
time.
48:22.168 --> 48:26.641
These days my pair programmer, so to speak, is the coding agent and that's how I look at
it.
48:26.641 --> 48:29.962
I'm overall framing for it and it is solving for me.
48:29.962 --> 48:37.706
The one part I miss about it is the other partner should ideally frame the problem for me
and me solving it so I can keep going back and forth.
48:37.706 --> 48:40.627
I don't see that happening so right now I'm more of
48:42.080 --> 48:42.542
Yeah.
48:42.542 --> 48:44.517
coding agent does solve solve solve.
48:44.529 --> 48:50.063
As a team, if you're looking at it, I also use a ton of sub-agents and agent teams, et
cetera.
48:50.063 --> 48:52.135
So it's not just one agent I'm talking to.
48:52.135 --> 48:55.898
So I'm submitting work to a team of agents, right?
48:55.898 --> 49:02.901
So what I do is just for fun sometimes I, and actually for good benefit, is I create a
pair of engineers.
49:02.901 --> 49:12.126
So like one is the adversarial of the other, and they kind of fight between each other,
again, in good spirit to get the right content out for me,
49:12.807 --> 49:16.489
Agents try to please us as much as possible.
49:16.489 --> 49:22.052
for one agent, if my goal is write the code, the other one is try and find a way to break
this code.
49:22.052 --> 49:27.786
So then I can have both of them sort of do that duel and come back to me with code that I
would be happy with.
49:27.786 --> 49:31.047
So yeah, that's the current version of pair programming I'm dealing with.
49:31.047 --> 49:31.689
God.
49:31.689 --> 49:33.809
Right, yeah, no, it makes sense.
49:33.809 --> 49:34.400
Holy cow.
49:34.400 --> 49:38.731
What cultural shift do you think is required for AI native software development lifecycle?
49:38.731 --> 49:44.402
Yeah, so for me, the big shift is the fact that conversations are more important, right?
49:44.402 --> 49:45.355
I think the
49:45.355 --> 49:48.056
thought that, OK, there's new models coming out every day.
49:48.056 --> 49:53.459
There's opus, and there is mythos, and everyone's like, OK, we just want more intelligent
models.
49:53.459 --> 49:56.360
And the models will sort of magically do better.
49:56.360 --> 49:57.140
And they do.
49:57.140 --> 49:58.071
I'm not denying that.
49:58.071 --> 50:02.623
Models are definitely getting better at figuring out code and whatnot.
50:02.623 --> 50:10.237
But uh the bigger point here is, am I trying to hire more smarter engineers and then just
hope that they'll read my mind?
50:10.237 --> 50:12.628
That's not necessarily true.
50:12.628 --> 50:14.509
I want to be able to have a
50:14.509 --> 50:24.609
conversation have a system in place for collaborating properly so that irrespective of
models that I'm using I should be able to get consistent output and that I feel is really
50:24.609 --> 50:31.069
important as a cultural shift to focus on the conversation with AI rather than looking at
it as an instruction, right?
50:31.069 --> 50:33.149
It's a collaborative context building.
50:33.149 --> 50:38.231
Why that is critical is almost like that takes you out of lock-in, you know, analogy wise.
50:38.231 --> 50:43.841
Do I want to lock in myself with smarter models and I cannot deal with like maybe the $2
model?
50:43.841 --> 50:46.173
or the $20 model, I only need a $200.
50:46.173 --> 50:57.440
So I feel the collaborative context building sort of wins hands down when compared to
saying, I'll just depend on the model itself.
50:57.460 --> 51:02.344
that's my big cultural shift that is necessary to think about individually as well as
teams.
51:02.344 --> 51:04.140
This kind of goes at that level.
51:04.140 --> 51:04.780
for sure.
51:04.780 --> 51:08.581
Well, and I think you've touched on how you hire staff, train, mentor.
51:08.581 --> 51:09.522
And I think you're right.
51:09.522 --> 51:16.874
The culture, it is definitely more and more this job is going to have to be about
understanding the business domain and talking about the business domain and talking about
51:16.874 --> 51:19.096
the intent, talking about the problem you're trying to solve.
51:19.096 --> 51:20.877
So I think that's 100 % right.
51:20.877 --> 51:24.688
Are you seeing anything change around like role ratios?
51:24.688 --> 51:31.193
There was a time when you could almost have a little bit of a magic framework of like, if
you've got five developers, you're to need one.
51:31.193 --> 51:34.476
business analysts and maybe a QA depending on how you're doing QA.
51:34.476 --> 51:37.438
And these ratios kind of stood for a long time.
51:37.438 --> 51:39.059
Obviously they would need adjustment.
51:39.059 --> 51:41.282
But you could kind of stamp them out a little bit.
51:41.282 --> 51:42.393
Is that changing?
51:42.393 --> 51:45.675
Like some people say like, we're clearly going to need more testers.
51:45.675 --> 51:47.887
And some people say, we're going to need more SMEs.
51:47.887 --> 51:50.458
And some people say, well, we're all product people now.
51:50.458 --> 51:57.114
But yeah, what are you seeing in terms of the impact of role ratios and how many
developers, QA to BA and all of this?
51:57.114 --> 52:02.258
I think the wave is yet to hit a lot more companies than we would like to see right now.
52:02.258 --> 52:04.298
Right now, at least this is my experience, right?
52:04.298 --> 52:12.394
And my clients, we're trying to move to help the existing teams get where they want to
with the current structure.
52:12.394 --> 52:22.430
And within those roles, am seeing no problem at all when people move from, let's say,
everyone universally needs to get more product acumen so to speak, right?
52:22.430 --> 52:23.811
They need to understand the product.
52:23.811 --> 52:30.194
or the business that they're trying to deal with because they're elevating themselves from
the day-to-day current of like actually executing.
52:30.194 --> 52:31.814
So that is a given.
52:31.814 --> 52:43.482
In terms of ratios in the team, I don't see
a reason why to change right now because at
least the fact everyone had their position, so to speak, from a human centric workflow
52:43.482 --> 52:47.334
point of view, and there were a certain ratio required to satisfy that.
52:47.334 --> 52:50.527
But if you take the same ratio and apply it to...
52:50.527 --> 52:53.179
putting the system together like of agents.
52:53.179 --> 52:55.530
Right now, let's take example of QA, right?
52:55.530 --> 53:01.294
I like that example a lot because I feel like unnecessarily we say that, we don't need QAs
or we need more QAs.
53:01.294 --> 53:03.576
What we really need is what does the QA do now?
53:03.576 --> 53:09.310
The point is the QA has to now ensure the quality of the harness or the quality of the...
53:09.310 --> 53:16.161
system that is putting the context together to build applications so that the bugs don't
get created in the first place, right?
53:16.161 --> 53:22.238
So there's still a lot of work, there's still a lot of software engineering that needs to
be done in the system building.
53:22.238 --> 53:31.374
And if you have as many developers, if you have as many QAs, as long as you're able to
push them onto like system building part of it, it still works that ratio.
53:31.374 --> 53:35.856
But honestly, I don't want to say like, you know, this ratio will continue to work
forever.
53:35.856 --> 53:38.857
ah In due course, I think the biggest
53:38.857 --> 53:49.239
that's going to happen is for all of us to become more business centric and actually user
centric because as we push these things out we need to be able to look at it as better
53:49.239 --> 53:58.350
systems thinkers rather than individual roles we could still be SMEs but we are largely a
one collective mind trying to stage work for the agent.
53:58.350 --> 54:00.162
Yeah, oh wow, that's nice.
54:00.162 --> 54:01.894
Cool, one collective mind indeed.
54:01.894 --> 54:06.498
Okay, so you've been very generous with your time, but we're sort of rolling towards a
close.
54:06.498 --> 54:15.033
There's three questions I ask everybody at the end of this, and you can definitely answer
these about your career, about AI, whatever, but it can also just sort of be anything in
54:15.033 --> 54:15.945
your life, right?
54:15.945 --> 54:18.987
the first one, almost everyone answers the same way.
54:18.987 --> 54:21.769
So if you fall into that trap, I will point it out.
54:21.769 --> 54:25.043
But so the first question, what is something you've had to change your mind on?
54:25.043 --> 54:30.527
Something that you thought you were right about for a long time and realized, oh, wait,
no, that's not true.
54:30.527 --> 54:32.132
What comes up for you when I ask that?
54:32.132 --> 54:34.013
proven wrong more than once.
54:34.013 --> 54:38.795
And this has been the recent thing that this has been, again, a deja vu moment.
54:38.795 --> 54:40.486
I always thought of.
54:40.486 --> 54:42.757
like technology for the sake of technology, right?
54:42.757 --> 54:47.766
But practically, technology is way to address human aspect of it.
54:47.766 --> 54:54.208
It's a way to address the political aspect, dynamic of it in teams or companies and
whatnot.
54:54.208 --> 54:58.339
So for me, architecture was the first time when I was trying to do digital transformation
sort of work.
54:58.339 --> 55:04.430
I realized that architecture was a vehicle for me to enable good dynamics in the team.
55:04.430 --> 55:08.144
And how you technically put systems together is how you
55:08.144 --> 55:11.244
you get people to positively collaborate with each other.
55:11.244 --> 55:12.255
So that's number one.
55:12.255 --> 55:16.675
And eventually I did think that, know, dynamics still plays an important role and whatnot.
55:16.675 --> 55:20.577
And now with AI, I again see the collaboration aspect of it.
55:20.577 --> 55:23.674
What I feel humbled about is, you got to...
55:23.674 --> 55:28.707
give people more credit than what we do, at least for me, usually.
55:28.707 --> 55:30.829
The people dynamics is most important.
55:30.829 --> 55:31.950
Technology comes later.
55:31.950 --> 55:37.742
So if I put people first, that's how I stumbled upon intent-driven development as an idea
and developed on it.
55:37.742 --> 55:39.290
And it kind of goes well for me.
55:39.290 --> 55:46.314
And I'm really happy I'm standing corrected in terms of not overly focusing on AI and
saying, hey, I don't really need a team.
55:46.314 --> 55:49.956
I badly need a team now than like ever.
55:49.956 --> 55:51.136
And
55:51.627 --> 55:59.537
This is one yet another proof that I've had to change my mind like you know, is Knowing
people always is more important than knowing tech
55:59.537 --> 56:02.368
Yeah, yeah, yeah, yeah, yeah, 100%.
56:02.368 --> 56:03.711
What's something you're most proud of?
56:03.711 --> 56:09.777
In recent times, think what I'm most proud of is being able to enable people who...
56:09.777 --> 56:10.936
They're really smart.
56:10.936 --> 56:21.660
much better than I am at critical thinking and whatnot, but probably their articulation
capability, language and other things were what was stopping them from achieving what they
56:21.660 --> 56:22.440
wanted.
56:22.440 --> 56:33.196
But now using this coding tools and coding agents and interacting with them with some of
the groups that I've been working with, even people are able to use our vernacular
56:33.196 --> 56:34.958
language to build software.
56:34.958 --> 56:36.899
And I'm able to get a few
56:36.939 --> 56:44.544
young chaps to build software from purely like local languages like Kannada, Tamil and
that's very big win for me.
56:44.544 --> 56:47.826
I'm still in the early stages of it and I love that part, right?
56:47.826 --> 56:56.562
Like, you know, to say I don't need this individual to know English or converse there to
build stuff like I'm still in the early phases of that but if there's anything I'd be
56:56.562 --> 56:58.447
proud of, I'd be proud of that small bit.
56:58.447 --> 56:59.529
that's amazing.
56:59.529 --> 57:00.850
Yeah, yeah, yeah, yeah.
57:00.850 --> 57:09.192
It's funny, we talk about like, oh, know, these languages come from C with the curly
braces and the semicolons, and these languages come from basic, and it's like, no, they
57:09.192 --> 57:10.423
all come from English in the end.
57:10.423 --> 57:11.866
So I love what you're doing.
57:11.866 --> 57:12.667
That's awesome.
57:12.667 --> 57:13.508
Cool.
57:13.508 --> 57:15.021
What's something that's giving you joy right now?
57:15.021 --> 57:21.025
So ah I think I've rediscovered sort of being closer to program and code.
57:21.025 --> 57:30.685
There's a lot more code I see compared to like, again, being a consultant, a large part of
my time, I imagine you can realize it goes towards like people interaction, setting up
57:30.685 --> 57:32.737
dynamics and systems and stuff like that.
57:32.737 --> 57:37.260
Building things is something that I've been yearning to do a lot more of.
57:37.260 --> 57:42.453
And now I'm really addicted to like building stuff, like an idea I have I can take.
57:42.453 --> 57:47.027
get implementation very quickly, see it take like a shape very quickly, right?
57:47.027 --> 57:50.540
That's, in a way, I don't know, it's a good thing or, yeah, it is a good thing.
57:50.540 --> 57:56.024
Like it's addictive, it's very nice to see I can, I don't have to be limited by my time.
57:56.024 --> 58:01.778
it's, the agent can multiply the ability to execute is what's giving me joy right now.
58:01.778 --> 58:02.992
Amazing.
58:02.992 --> 58:03.794
Hari Krishna.
58:03.794 --> 58:06.012
Thank you so much for spending some time with us today.
58:06.012 --> 58:07.481
Really appreciate you coming on the podcast.
58:07.481 --> 58:08.183
Thank you, Kyle.
58:08.183 --> 58:10.321
I think it's wonderful having a conversation with you.
58:10.321 --> 58:11.207
And thank you for having
58:10.575 --> 58:10.693
me.