WEBVTT

00:00.018 --> 00:08.662
I've actually gone through some sort of an existential crisis, to be honest, where you
kind of think what the hell is going on and where is this all headed, sort of thing.

00:09.142 --> 00:10.995
I think we are headed

00:11.591 --> 00:14.890
people need to start thinking product more.

00:14.890 --> 00:15.213
Yeah.

00:15.254 --> 00:17.736
product engineer thing is really kind of happening.

00:17.736 --> 00:18.250
Yeah.

00:18.433 --> 00:25.827
Guru prasad Venkatesh, Guru to his friends, joined the ThoughtWorks Bangalore office in
2006, where he continued to work for 12 years.

00:25.827 --> 00:29.961
Guru and I got to work together in Cincinnati, Ohio for Kroger, the big grocery chain.

00:29.961 --> 00:37.445
After ThoughtWorks and a brief stint at Cloudera, Guru went on to co-found Beskar
Technologies, where he serves today as chief architect.

00:37.505 --> 00:44.725
In addition to their custom software development services for customers, Beskar is also
building Baid an agentic AI dev tool, and

00:44.725 --> 00:47.771
Guru is our guest today on the Engineering with AI podcast.

01:04.809 --> 01:06.226
Guru, thanks so much for joining today.

01:06.226 --> 01:07.553
I really appreciate it.

01:08.149 --> 01:10.245
Hi Kyle, yeah thanks for having me here.

01:10.245 --> 01:14.213
It was really nice working with you as well at Kroger in Cincinnati.

01:14.400 --> 01:15.680
For sure, those were the good old days.

01:15.680 --> 01:20.180
I remember you endlessly running JMeter to fix performance problems that the team and I
had made.

01:20.300 --> 01:21.721
So thank you.

01:21.721 --> 01:23.359
So let's kind of start with you.

01:23.364 --> 01:24.019
Yeah,

01:24.458 --> 01:28.299
Beskar there are two other partners that we started Beskar with.

01:28.299 --> 01:31.259
And one of them, Jake, is an ex-thought worker.

01:31.319 --> 01:34.999
In fact, he was the one who referred me to ThoughtWorks back in 2006.

01:36.319 --> 01:38.399
And interestingly, we are school buddies.

01:38.399 --> 01:45.219
I've known him from my third grade, third class, class three to class eight, after which
he moved out our town.

01:45.219 --> 01:47.999
His dad got transferred to Gujarat.

01:48.361 --> 01:50.093
And we kept in touch after that.

01:50.093 --> 01:52.115
And he came back to Bangalore.

01:52.115 --> 01:56.179
And he had started this other company called Mavenhive once he left ThoughtWorks.

01:56.179 --> 01:57.601
And that got acquired.

01:57.601 --> 02:00.804
And then he wanted to leave that new company.

02:00.804 --> 02:06.934
And then I had left ThoughtWorks and joined CloudEra because I was very interested in data
engineering and data science and that domain.

02:06.934 --> 02:10.344
But then after

02:10.344 --> 02:16.584
I think one and a half years at Cloudera I decided to move on and at the same point he was
leaving his new company.

02:16.844 --> 02:25.364
So we both got together and decided that, yeah, I mean, he always was, tried to hire me
into Mavenhive.

02:25.464 --> 02:28.864
And then at some point we decided, yeah, it's a good time to start.

02:28.864 --> 02:34.405
So him, Nitin is the other partner and me, we started Baskar.

02:34.405 --> 02:36.665
the core...

02:36.746 --> 02:49.686
philosophy, mean the ideas, the way we work, it's very ThoughtWorks influenced because a
lot of, mean the folks that we worked with spent many years at ThoughtWorks.

02:49.686 --> 02:51.766
Yeah, so it's pretty, it's quite interesting.

02:51.766 --> 02:54.126
We've not grown a lot.

02:54.126 --> 03:00.666
We're just like 14, 15 strong after five years.

03:01.126 --> 03:03.046
Yeah, so that's the best.

03:03.185 --> 03:06.489
When you say ThoughtWorks like some of our audience will know what that means.

03:06.489 --> 03:14.055
For the rest, I think very extreme programming oriented, so test-driven development and
continuous integration, continuous delivery.

03:14.055 --> 03:15.977
the other thing that comes to mind for me is,

03:15.977 --> 03:18.230
very different hierarchical or no hierarch.

03:18.230 --> 03:24.847
I remember telling everybody I'm sure I didn't have a boss for a lot of years, like where
I didn't know who my boss was at least, and pretty sure I didn't have one.

03:24.847 --> 03:27.350
So I wonder like how about those parts?

03:27.350 --> 03:28.741
did that also come through?

03:28.741 --> 03:29.872
Yeah.

03:30.198 --> 03:30.668
Yeah, yeah.

03:30.668 --> 03:41.376
I mean, I think that's one of the things that I had a hard time dealing with after I left
ThoughtWorks because it's so transparent and you don't actually report to anybody or ask

03:41.376 --> 03:42.247
anybody for...

03:42.247 --> 03:46.009
I mean, you share your leave plans beforehand, but apart from that, there's nothing.

03:46.009 --> 03:49.612
Yeah, mean, so Beskar is, yeah, it's similar.

03:49.612 --> 03:52.714
We three are partners, but we are the same.

03:52.714 --> 03:56.397
We kind of work on projects just like everybody else.

03:56.397 --> 03:58.198
We don different hats.

03:58.198 --> 04:08.385
in pursuing leads, like I might play the tech architect role when somebody is asking for
an RFP for a new project, things like that.

04:08.385 --> 04:10.706
Jake might be involved initially.

04:10.706 --> 04:12.868
It actually totally depends.

04:12.868 --> 04:16.710
But it's pretty fluid and we've kind of grown organically as well.

04:16.710 --> 04:25.768
And the ways of working that's very thought works influenced in the sense that, like you
said, it's very extreme programming.

04:25.768 --> 04:34.310
very visible short sprints like we try and show our work as often as possible yeah all
that good stuff

04:34.310 --> 04:42.088
Well, I like to start with how you personally are using these tools and being the chief
architect, like maybe you're coding every day still.

04:42.088 --> 04:46.750
You tell me, but I can tell you probably got some use of these tools.

04:46.750 --> 04:48.892
So what do you like?

04:48.892 --> 04:50.373
Maybe a little bit about like what

04:50.373 --> 04:57.600
languages you're working in, but more importantly, what Gen.AI tools are you using and
what's working for you and what's not working for you?

04:57.600 --> 04:59.413
What do you like, personally?

04:59.436 --> 05:09.950
Yeah, so I've kind of dabbled with LLM's Gen.AI from GPT 3.5 days, like 2022 initially
when it was released.

05:10.395 --> 05:12.684
at that point, we working with

05:12.684 --> 05:24.481
this company that was trying to solve interesting problems in the recruitment space,
trying to improve an interviewer's process and make interviewing better And this LLM GPT

05:24.481 --> 05:34.425
3.5 fits so perfectly there because they were trying to summarize interview notes and do
things like that that actually help in the interviewing process.

05:34.425 --> 05:37.356
And this is even when lang chain was not a thing.

05:37.356 --> 05:39.047
So we had to develop our own.

05:39.257 --> 05:42.530
AI client that now people call agents.

05:42.530 --> 05:48.476
So essentially that had to build that system and use a prompt and keep sending it to the
LLM to give back answers.

05:48.476 --> 05:51.639
We had to interpret answers, build those chains and things like that.

05:51.639 --> 05:58.747
So yeah, mean, at that point, it was very interesting, but I didn't have a lot of
confidence because there were so many hallucinations and...

05:58.841 --> 06:04.815
you ask it for a yes or no answer and it kind of always, that doesn't give you that
consistently, right?

06:04.815 --> 06:06.176
But then it kept improving.

06:06.176 --> 06:07.837
That's what I've seen over the years.

06:07.837 --> 06:17.965
And one of the things that we used is the function spec, wherein you can say that I want
the answer in this format and you can share a function spec with it.

06:17.965 --> 06:20.928
So that improved the quality of answers and things like that.

06:20.928 --> 06:23.191
personally, I've used ChatGPT right now.

06:23.191 --> 06:26.933
I use ChatGPT for a lot of the personal stuff.

06:27.011 --> 06:30.865
like managing health or basically asking it for diet.

06:30.865 --> 06:36.548
I go to the gym so it kind of plans my meal plans or workout what I should be doing and
things like that.

06:36.548 --> 06:39.829
In fact, we were discussing some product ideas around that.

06:39.829 --> 06:42.351
But yeah, I use Claude code heavily.

06:42.351 --> 06:46.492
And Claude code is one of the best tools, think, out there.

06:46.492 --> 06:48.993
Played around with WindSurf a little bit.

06:50.459 --> 06:50.981
Yeah.

06:50.981 --> 06:52.741
with GitHub Copilot.

06:52.741 --> 06:54.721
I thought it was really, really good.

06:54.841 --> 06:59.701
Magical, basically the way it kind of generated your code based on context.

07:00.901 --> 07:09.501
But at that point, my thought process was that it is good for eliminating the need to
write or type plumbing code.

07:10.801 --> 07:15.001
So based on the code in a file, can just auto-generate stuff.

07:15.171 --> 07:16.991
But it kept getting better and better.

07:16.991 --> 07:24.411
with Claude Code, in Beskar, I've been the most skeptical in using any of these tools.

07:24.851 --> 07:30.471
And I've always been played the devil's advocate when people have conversations around
this saying, about this?

07:30.671 --> 07:33.071
It made this mistake and things like that.

07:33.071 --> 07:36.011
And I still am quite skeptical.

07:36.262 --> 07:38.662
But yeah, Claude Code I think, is very powerful.

07:38.662 --> 07:40.902
And that's what we use on a day-to-day basis.

07:41.332 --> 07:41.625
Yeah.

07:41.625 --> 07:51.945
And also one other really powerful tool is Kiro I don't know if you've kind of heard of
it, it is primarily a spec-driven development tool.

07:52.965 --> 07:57.585
It is like, yeah, yeah, yeah.

07:57.585 --> 08:02.649
So it's basically based on Visual Studio Code and...

08:02.649 --> 08:05.069
they've introduced this workflow.

08:05.149 --> 08:12.649
So they are kind of having an opinion on how you should go about using AI agent in code
coding assistance.

08:12.909 --> 08:20.369
So it starts with writing a specification and then that gets converted to your user
stories and then tasks.

08:20.369 --> 08:27.349
And they have this sort of a markdown template where you can go and click on a task and
say, want to execute this.

08:27.549 --> 08:31.149
So I found that to be really useful.

08:31.974 --> 08:36.803
And I think that's the way we are advocating the usage of Claude Code as well right now.

08:36.803 --> 08:41.277
So yeah, think Claude Code is the primary coding tool we're using.

08:41.277 --> 08:41.878
That's interesting.

08:41.878 --> 08:46.862
The first mention I'd heard of Kiro, we had Tim Cochran on the show recently.

08:46.862 --> 08:51.406
I think he's the latest article right now, though Chris Ford's will drop on Sunday.

08:51.406 --> 08:54.849
yeah, and he uses it because he's at Amazon, right?

08:54.849 --> 08:56.111
And they're the ones that make it.

08:56.111 --> 08:57.632
And I think there's a rule.

08:57.632 --> 08:58.673
I think they have to use it.

08:58.673 --> 08:59.863
I don't think they have an option.

08:59.863 --> 09:03.834
And so, but you're actually almost telling me more about how it works than he did.

09:03.834 --> 09:05.625
He just sort of assumed some knowledge.

09:05.625 --> 09:07.225
Anyhow, you're making me want to go try it.

09:07.225 --> 09:07.906
That's cool.

09:07.906 --> 09:16.330
do you use it somehow in conjunction with Claude Code or you, or it's just sort of like,
nah, you, you like the spec driven in part, but it's, it's not as good at code.

09:16.330 --> 09:17.000
So you don't use it.

09:17.000 --> 09:19.871
Like how, help me tease out your thoughts there.

09:20.062 --> 09:25.506
Yeah, mostly it was an experiment with Kiro Just to was curious on that way of working.

09:25.506 --> 09:30.319
Because it sounded really interesting and in line with the way we do things usually.

09:30.319 --> 09:35.132
Like we don't kind of give a general prompt and say, hey, build this whole entire system.

09:35.132 --> 09:41.206
We kind of break it down and then do it a uh thin slice and in iterations.

09:41.206 --> 09:41.734
So.

09:41.734 --> 09:47.381
Yeah, I I've played around with Kiro but haven't used it heavily, to be honest.

09:47.442 --> 09:54.752
And one of the distinguished engineers in Amazon who I follow, he was kind of advocating
Kiro.

09:54.752 --> 09:56.314
And that's how I got to know about it.

09:56.314 --> 09:59.517
And I was interested in learning about it.

09:59.517 --> 10:00.718
Cool, cool.

10:00.718 --> 10:03.260
I like how you talked about originally as plumbing code.

10:03.260 --> 10:09.824
I think one of my first ever interactions, it was actually ChatGPT that made me think,
wow, this thing can write code.

10:09.824 --> 10:14.248
I was working on an aviation project and I wanted to deinterlace.

10:14.501 --> 10:15.902
radar signals.

10:15.902 --> 10:20.685
I had, it looked like I had an airplane that was jumping all over the screen and it didn't
make any sense.

10:20.685 --> 10:24.207
But what was really happening is it was a time signal from 10 a.m.

10:24.207 --> 10:25.909
and another signal from 11 a.m.

10:25.909 --> 10:30.092
that had been like merged as though it was a time zone problem, right?

10:30.092 --> 10:31.343
And so the 10 a.m.

10:31.343 --> 10:32.283
flight and the 11 a.m.

10:32.283 --> 10:37.058
flight were like being merged like a zipper together and that's why it didn't make any
sense.

10:37.058 --> 10:40.944
So I went and asked Chat GPT like is there math that can help me do this?

10:40.944 --> 10:44.307
And it was like, here's the history of radar and how this has worked.

10:44.307 --> 10:49.962
I'm like, oh, and then at the end, here is like 25 lines of Python and they worked.

10:49.962 --> 10:56.217
And that was like one of my first introductions to like, yeah, this thing, this is more
than just, you know, vibe coding.

10:56.217 --> 10:57.449
There's something really here.

10:57.449 --> 11:07.375
Yeah, but like you say, the plumbing code, taking the drudgery away, I think that's an
early like win, I think, that gets a lot of people interested.

11:07.744 --> 11:15.596
Yeah, but it sounded like you're doing more than just plumbing code now, but you also said
your approach is normally to break things down into smaller pieces.

11:15.596 --> 11:21.211
Can you talk more about what sorts of guardrails you do use when you're approaching
things?

11:21.211 --> 11:26.084
Yeah, so I don't write a lot of code on a daily basis now.

11:26.084 --> 11:32.970
I'm mostly involved with client, maintaining client relationships and architecture and
things like that.

11:32.970 --> 11:40.596
So I use Claude in the plan mode mostly just initially to come up with ADRs.

11:40.596 --> 11:46.410
Basically, you use it as a bouncing board just to figure out what the architecture options
are.

11:46.454 --> 11:49.995
trade-offs of you going down one path, uh things like that.

11:49.995 --> 11:51.367
And it's very good.

11:51.367 --> 11:57.552
It's very powerful because it's yeah, it's like talking to another senior developer and
bouncing off ideas, right?

11:57.552 --> 12:00.233
So uh that's very good.

12:00.233 --> 12:12.800
But yeah, when I have done development, I start out with plan mode and try and, like, if I
had to do a big refactoring, right, where I wanna migrate.

12:12.800 --> 12:18.494
Like I want to improve the quality of code in certain parts of the code base.

12:18.494 --> 12:24.038
I try and break it down and basically ask Claude Code in the plan mode to do it.

12:24.318 --> 12:31.823
And then it comes up with a plan and then I kind of review it and then go and see what can
be improved there.

12:31.824 --> 12:33.525
And then do it step by step.

12:33.525 --> 12:37.962
think the idea is to avoid making big bang changes as much as possible.

12:37.962 --> 12:38.849
Yeah.

12:38.862 --> 12:46.167
keep things a little more controlled because it can actually go berserk sometimes and it
also sometimes complicates things.

12:46.167 --> 12:54.871
Like you have to point out that the problem is already solved in a script somewhere and
you can just reuse that rather than write another new script.

12:55.692 --> 12:56.872
Things like that.

12:57.233 --> 13:03.587
I have fallen in this trap where you kind of give it access to everything like AWS
CloudWatch logs.

13:03.587 --> 13:05.468
go and look at your CI failures and everything.

13:05.468 --> 13:09.242
And then you keep saying, yes, yes, yes to our whatever it does and then become lazy.

13:09.242 --> 13:17.168
It actually does a decent job most of the times, but it can get into a loop and the
solution usually is very simple.

13:17.168 --> 13:20.350
Like it would have been using the wrong binary on your machine.

13:20.350 --> 13:24.592
Like that's built for Intel rather than for, and then it'll crack its head.

13:25.233 --> 13:27.955
And then I'm like, yeah.

13:29.582 --> 13:31.223
It just keeps working hard.

13:31.223 --> 13:33.895
There's a lot of trial in the way it does things sometimes.

13:33.895 --> 13:38.777
And I think when you step in at that point, you have to nudge it.

13:40.208 --> 13:45.571
whatever we have thought of and ideas that we come up with, we see that Claude or
Anthropic.

13:45.571 --> 13:48.172
They implement that in a week or so.

13:48.172 --> 13:52.583
So every week, they come up with these features that are kind of really...

13:52.583 --> 14:02.668
very powerful, like for example, the skills feature, or you can have your own agents, or
the tools you can use, the memory tool especially, things like that.

14:02.583 --> 14:15.423
recently we've started to do trainings with companies where we kind of train on how to use
coding agents like Claude code effectively.

14:15.674 --> 14:26.770
One of the main things there is to do this breakdown of tasks into small tasks and then
use the plan mode, use skills, use memory as much as possible and try and be efficient

14:26.770 --> 14:34.886
about the usage of context basically the idea is that you have this sort of structure in
the way you approach.

14:34.886 --> 14:44.591
you're utilizing Claude Code and have certain things in place, like a skill set, basically
workflows for solving various problems, very, very different hats, like for example, a QA

14:44.591 --> 14:49.282
hat or a Cloud Architect hat or a security SecOps hat.

14:49.442 --> 14:56.244
And then look at your statement, like basically problem statement in these different
angles, right?

14:56.244 --> 14:58.345
Yeah, so some of that.

14:58.410 --> 15:04.989
like saying, Claude, act as a quality assurance person in that kind of style where you're
giving it like an agent's description.

15:06.011 --> 15:08.577
Yeah, got it, got it, got it, for sure.

15:08.577 --> 15:18.557
that this particular folder has some changes that are related to authentication or RBAC or
things like that.

15:18.557 --> 15:21.217
And we want to be doubly sure that we're not breaking anything.

15:21.477 --> 15:31.597
So essentially, you ask Claude to execute a story that is maybe related to introducing
some sort of token-based authentication mechanism.

15:31.671 --> 15:40.708
And then you use one of these agents, sub-subagents, that can use a particular skill set
to verify that change and ensure that nothing is broken.

15:40.708 --> 15:47.092
I mean, of course, that can also be done with tests, but just use the non-deterministic
nature of things.

15:47.092 --> 15:49.694
You ask it to verify as well.

15:49.722 --> 15:53.067
Let's start thinking about also the teams that you serve, right?

15:53.067 --> 16:00.696
So not just your own work, but teams at Beskar, maybe customer teams that you can see when
you're working on custom software development.

16:00.696 --> 16:03.511
What kinds of changes are you seeing in?

16:03.511 --> 16:11.795
And maybe if you want to think about this in terms of what a mature team is doing versus
what teams that are new are doing, whatever stories you want to share are interesting.

16:11.795 --> 16:15.237
But how are you seeing this impact teams in a big way?

16:15.237 --> 16:19.950
Yeah, I think in general, right now the expectations are high.

16:19.950 --> 16:26.923
essentially, people, customers expect you to be very productive, given that you use these
powerful tools.

16:27.184 --> 16:28.344
That's one change.

16:28.344 --> 16:35.568
yeah, I mean, just in terms of the usage of tools themselves, customers have come to us
asking for help.

16:35.810 --> 16:39.243
in figuring out how to use these tools effectively, like I was saying.

16:39.243 --> 16:48.731
So essentially, how to avoid just vibe coding and just build something up very quickly
that quickly becomes unmaintainable.

16:48.731 --> 16:51.644
That you have so much code and that it's hard to debug.

16:51.644 --> 16:57.200
You just put that in production and then it becomes difficult to debug and maintain in
production.

16:57.200 --> 17:00.083
So those are the kinds of problems that customers come to us with.

17:00.083 --> 17:04.948
What changes are you seeing in product management and in story breakdown and these kinds
of things?

17:04.948 --> 17:05.567
Oh yeah

17:05.542 --> 17:05.923
absolutely.

17:05.923 --> 17:07.826
mean, Claude can help with that as well.

17:07.826 --> 17:18.682
So essentially, you think of an inception in ThoughtWorks where you kind of get gathered
at a client site and brainstorm and come up with these ideas and the output of that whole

17:18.682 --> 17:21.314
Declan inception is a master story list, right?

17:21.314 --> 17:26.489
Where you have like a very refined set of stories that your team can get started with.

17:26.489 --> 17:28.373
I think Claude Code and

17:28.373 --> 17:34.726
ChatGPT and tools like that can really help in breaking things down, given a set of
criteria.

17:34.726 --> 17:45.602
Like we did this for one of our clients where we said, this is a product requirements
document, and I want you to break it down into features where you capture the story

17:45.602 --> 17:51.794
description, the volatility of the requirement, any questions, a high level estimate based
on what you've done.

17:51.794 --> 17:52.614
and things like that.

17:52.614 --> 17:56.567
And it's really powerful, and it can actually do a really good job there as well.

17:56.567 --> 18:00.140
And so generally, think you can be very fast.

18:00.140 --> 18:06.783
I mean, you can move really fast when it comes to understanding, like breaking things down
and things like that.

18:06.783 --> 18:09.683
ah

18:09.683 --> 18:10.904
fast reader.

18:10.904 --> 18:21.309
It's funny when you're, when you're talking about this, I'm thinking about an inception
Kroger in fact And a previous, sort of waterfall process had generated like an 80 page,

18:21.309 --> 18:26.021
you know, product requirements document, you know, business analysis, you know, package.

18:26.021 --> 18:31.744
like job number one was reading that thing, you know, and it wasn't necessarily internally
consistent with itself.

18:31.744 --> 18:32.815
Like what, what it was saying.

18:32.815 --> 18:38.257
And, and, know, we did, we, we sat down and plowed through it and tried to find, okay,
this is, this is.

18:38.257 --> 18:45.164
where it says this way that way and says it that way over here and like which one is right
and Claude would have done a very quick job of that.

18:45.164 --> 18:53.962
it would have done that in minutes you know and it it took us hours so but when you when
you say like breaking a PRD down into stories you guys probably wrote the PRD in the first

18:53.962 --> 18:56.674
place I guess or tell me how that goes.

18:56.871 --> 19:04.146
Yeah, it was written manually by somebody from the client side, a product owner from the
client side.

19:04.386 --> 19:14.464
But the interesting thing is also that with persistent memory with Claude a lot of this
can be captured as specifications that Claude will actually remember.

19:14.464 --> 19:17.677
It can be checked in as part of your code base.

19:17.677 --> 19:22.380
And it can be used as, I mean, we used to acceptance tests that ensure that.

19:22.631 --> 19:23.588
like that.

19:24.067 --> 19:30.939
so the whole idea of breaking a PRD, which to begin with is a document that people
shouldn't be writing, think.

19:30.939 --> 19:35.092
That's not how you should be doing it.

19:35.853 --> 19:37.493
But it's what a lot of people do.

19:38.174 --> 19:47.458
So Claude can really help in breaking that down into not only stories, but stories with
acceptance criteria, which can be converted into a bunch of acceptance tests.

19:47.458 --> 19:48.288
Or your

19:48.378 --> 19:57.020
specifications which you adhere to right like and these can these can change over time and
you can go and edit them and yeah

19:49.056 --> 19:57.692
Yeah.

19:57.692 --> 19:58.373
Yeah, I love that.

19:58.373 --> 19:59.915
Especially the acceptance test part.

19:59.915 --> 20:00.376
That's neat.

20:00.376 --> 20:01.068
I hadn't thought of that.

20:01.068 --> 20:03.561
So my next question is usually architecture and planning.

20:03.561 --> 20:08.658
And you've talked about that a little bit, using Claude to generate ADRs and things like
that.

20:08.658 --> 20:10.580
uh Anything else coming to mind?

20:11.153 --> 20:12.175
No, think so.

20:12.175 --> 20:14.151
We had to choose between

20:15.122 --> 20:15.693
systems.

20:15.693 --> 20:19.560
Like basically, we looked at

20:20.232 --> 20:25.687
kind of forget the names but back in Kroger we used Shiro if you remember

20:25.687 --> 20:28.019
yeah, yeah, yeah.

20:28.499 --> 20:31.922
Are you thinking of like Auth0 and OKTA and things like that?

20:31.922 --> 20:32.802
Got it.

20:32.823 --> 20:34.544
Yeah, yeah, key cloak.

20:35.445 --> 20:36.138
Yep.

20:36.138 --> 20:44.334
loaded a bunch of these options and yeah, I mean, as a technical architect, you kind of
think of these parameters that you assist these options by, right?

20:44.334 --> 20:54.019
Like how many users can you, mean, how many concurrent requests can you make or what is
the feature set or how stable is it and what is the odd option?

20:54.327 --> 21:00.492
generally and what is the support like for these open source solutions or things like
that.

21:00.492 --> 21:09.719
So as an architect, you think of these things, but I think Claude, when I've used it, has
been very helpful in uncovering other aspects that you would have missed.

21:09.719 --> 21:14.022
um And also it can do research for you.

21:14.022 --> 21:20.667
So basically it pointed me to a benchmarking blog, which was kind of authoritative, which
kind of said, OK, this is how

21:20.995 --> 21:28.335
this tool performs with this kind of framework performance and this load, you know, like
under these conditions with this hardware.

21:28.515 --> 21:31.675
So just from a research point of view as well, it's very useful.

21:32.315 --> 21:45.656
Oh, actually, I forgot to mention perplexity, which is kind of what we use for research I
it's heavily, I think even Gemini does that for now, but it is citation based, right?

21:45.656 --> 21:49.680
Like any question you ask, they kind of ensure that they...

21:49.748 --> 21:54.194
cite very authoritative sources of information in coming up with an answer.

21:54.194 --> 21:59.181
I think uh even perplexity is something that we can use for coming up with good ADRs.

21:59.181 --> 22:02.223
ah

22:02.223 --> 22:03.403
I'll have to look at that.

22:03.403 --> 22:04.323
That's cool.

22:04.323 --> 22:07.823
I'd heard the name, but nobody had actually described to me what it is.

22:07.823 --> 22:09.663
So yeah, you're the first.

22:09.683 --> 22:10.323
Fantastic.

22:10.323 --> 22:11.103
Okay, cool.

22:11.103 --> 22:12.583
So perplexity for research.

22:12.624 --> 22:15.684
obviously software development itself, it changes.

22:16.424 --> 22:24.444
But what comes to mind for you when you think about how teams operate and how does
software development change with these Gen.AI tools?

22:24.444 --> 22:25.144
Yeah.

22:25.396 --> 22:26.816
Software development change.

22:26.816 --> 22:29.418
I think it can go a lot faster.

22:29.418 --> 22:41.622
I think we have to be mindful and go slower maybe because basically the idea is that you
can do so much in like a day that you can also incur a lot of tech debt.

22:41.622 --> 22:48.010
just in terms of software development, think like we were discussing before, you have to

22:48.010 --> 22:51.474
ensure that you have the right sort of guardrails in place.

22:51.474 --> 22:54.658
You are actually understanding what Claude is doing.

22:54.658 --> 23:03.584
And although Claude is writing code, you're still accountable for that code written and
you're still accountable for that working in production environments, right?

23:03.684 --> 23:09.588
from a software development point of view, I think you need fewer people maybe to get the
job done.

23:09.588 --> 23:12.918
ah

23:12.918 --> 23:24.536
pairing, I don't know if is relevant anymore because yeah, like basically Claude Code I
found that it can be a very good pair when it comes to debugging issues in production or

23:24.536 --> 23:26.117
debugging issues anywhere.

23:26.238 --> 23:37.271
In fact, it's kind of so helpful and it can weed out issues that you would, it would take
you like a day to figure out that it's some sort of a DNS issue somewhere, but it.

23:37.271 --> 23:38.472
can do that very, quickly.

23:38.472 --> 23:41.433
So that whole loop, that's very powerful.

23:41.573 --> 23:45.435
I mean, there are downsides to it, like we discussed, where it can go into its own rabbit
hole.

23:45.435 --> 23:50.481
But ah I think, overall, your development process, can go a lot faster.

23:50.481 --> 23:58.995
it's still, I mean, I'm still to speak to somebody who's done this on a project for like
six to eight months and put something in production and seen it work.

23:58.995 --> 24:08.215
with a lot of users and I don't know, I it just seems like everybody is jumping on this
bandwagon and people want to start using it.

24:08.555 --> 24:22.836
I think a lot of the learnings over the last 10 or 15 years that we apply from an
engineering practices, engineering principles standpoint still applies, right?

24:22.836 --> 24:25.416
Like we still need to...

24:25.449 --> 24:28.663
we still need to learn to design systems well.

24:28.663 --> 24:30.604
We need to think of edge cases.

24:30.604 --> 24:34.151
We need to be mindful of how much we building, things like that.

24:34.151 --> 24:42.788
But yeah, in the right hands, uh Claude Code or a coding tool like this can be very, very
powerful.

24:42.788 --> 24:42.970
Yep.

24:42.970 --> 24:43.962
Yeah.

24:43.962 --> 24:45.198
No, for sure.

24:45.198 --> 24:45.809
Totally agree.

24:45.809 --> 24:49.092
interesting, I normally ask about pair programming and mob coding too.

24:49.092 --> 24:50.733
And yeah, I'm so torn, right?

24:50.733 --> 24:54.048
Like I really came to love pair programming, working at ThoughtWorks.

24:54.048 --> 24:58.412
Like we were pair programming six, seven hours a day, you And it felt so powerful at the
time.

24:58.412 --> 25:02.586
But to your point, it doesn't feel as needed anymore.

25:02.586 --> 25:04.057
But doesn't that cause new problems?

25:04.057 --> 25:07.310
Like around like team alignment, team cohesiveness around the code base?

25:07.310 --> 25:10.091
Like, do you have any concerns there?

25:10.342 --> 25:13.985
uh I think some of those can be addressed if everybody is using.

25:13.985 --> 25:25.082
So one of the really good things with the previous way of working pre-AI was that, like if
you remember in Kroger, all of us used the same set of tools, right?

25:25.082 --> 25:31.297
And you could switch to any developer's machine and you could simply start writing code
without kind of...

25:31.297 --> 25:34.520
And we had a set of good uh guardrails in place.

25:34.520 --> 25:37.062
Like we had static type, static code checking.

25:37.174 --> 25:43.019
static uh code analysis, things like that, a right set of safety nets in place.

25:43.019 --> 25:44.241
And I think that still applies.

25:44.241 --> 25:55.374
So even when you're using AI, if everybody in the team is using the same set of
instructions in the form of Claude MD file, or the set of instructions that you pass on to

25:55.374 --> 26:01.152
the LLM, which can be a skill set, which can be your memory, lot of that can be shared
between team members.

26:01.152 --> 26:01.627
Yeah.

26:01.627 --> 26:04.429
and checked in as part of the code, right?

26:04.429 --> 26:10.335
So that way a lot of the context is shared and the coding agent becomes an active team
member.

26:10.335 --> 26:16.897
ah So I think that does solve part of the problem that you're talking

26:16.897 --> 26:17.548
I think you're right.

26:17.548 --> 26:24.089
I think some of that, like keeping the code cohesive is maybe not.

26:24.211 --> 26:26.822
It may be our responsibility, but not our job anymore.

26:26.822 --> 26:28.663
We're accountable, not responsible, something.

26:28.663 --> 26:33.425
But I also like what you're getting to there around like checking things in.

26:33.425 --> 26:35.803
That's been a question that's bugged me a few times.

26:35.803 --> 26:37.411
It's like, should we check everything in?

26:37.411 --> 26:39.930
Like from my experience, I'm normally working solo.

26:39.930 --> 26:43.372
So I can just check everything in and not think about it, not worry about it, you know?

26:43.372 --> 26:50.365
But on a team where you might have multiple developers going, does it make sense for,
okay, so yes, check in your Claude.MD I agree.

26:50.365 --> 26:52.337
To me that sounds like totally right.

26:52.337 --> 26:54.940
Check in skills, yes, right?

26:54.940 --> 27:02.327
Wait, does it make sense for there to be guru skills and team skills and maybe Beskar wide
skills?

27:02.327 --> 27:03.229
Like, I don't know.

27:03.229 --> 27:06.391
Is there anything you shouldn't check in that can you think of?

27:06.643 --> 27:13.853
Yeah, I mean, you can have personalized skills, I think, override what you're checking in.

27:13.995 --> 27:15.321
Yeah, yeah.

27:15.321 --> 27:20.815
but can you does it make sense to or should we or does it make sense to go towards sharing
everything?

27:20.815 --> 27:24.728
Like, can you think of a what would be outside of a share everything?

27:24.980 --> 27:27.131
Yeah, I can't think of anything that...

27:27.612 --> 27:32.208
I mean, basically, there's no data issue here, right?

27:32.208 --> 27:34.429
There's no data privacy issue here.

27:34.429 --> 27:37.902
It's just a set of guidelines and interacting with the LLM.

27:37.902 --> 27:43.946
And it's good for a team to share those guidelines so that you're...

27:44.187 --> 27:44.688
so that...

27:44.688 --> 27:51.254
it's a little bit deterministic, at least, the way Claude answers your questions, or, you
know, like the way it goes about solving the problem.

27:51.311 --> 27:52.070
Yep.

27:52.070 --> 28:03.297
and with persistent memory where it can retain that context across coding sessions that
kind of becomes important because there's uniformity there and every developer works their

28:03.297 --> 28:12.353
own way and they can have their own set of skills or their own style uh but from a yeah
yeah

28:12.353 --> 28:13.014
or something.

28:13.014 --> 28:19.458
So maybe, but nothing, so far I have not really seen anything where it's like, no, never
check in your plan files.

28:19.458 --> 28:21.169
Like no, check in the plan files.

28:21.169 --> 28:24.114
of course, people, yeah, you want to be able to see them.

28:24.114 --> 28:25.243
Okay, cool.

28:25.243 --> 28:34.449
I mean, of course, should be avoiding checking in files with sensitive content in it, some
sort of a key, API key or password or whatever.

28:34.449 --> 28:37.726
As long as you're avoiding that, I don't see any.

28:37.726 --> 28:42.958
file filled with social security numbers, like yeah, PII, things like that, no, for sure.

28:42.958 --> 28:45.869
that would have applied before, there's nothing new about that.

28:45.869 --> 28:48.210
yeah, okay, cool.

28:48.415 --> 28:50.886
You talked a little bit about testing earlier.

28:50.886 --> 28:57.579
You talked a little bit, I love how you talked about like a PDR can become an acceptance
test suite, for instance.

28:57.579 --> 28:58.580
Really, really cool.

28:58.580 --> 29:01.061
Are you seeing testing change in any other way?

29:01.313 --> 29:05.036
I think testing like development has become pretty easy.

29:05.036 --> 29:15.264
uh It's become very easy to write integration tests because Claude can do a lot of the
heavy lifting where you spin up a bunch of microservices using Docker compose, get that

29:15.264 --> 29:17.656
running in GitLab CI or wherever.

29:17.656 --> 29:23.048
It's become so easy to do that right now because if you would spend a of effort would go
in.

29:23.124 --> 29:27.045
to getting an end-to-end integration test to work, but that has changed.

29:27.286 --> 29:39.563
And from a unit testing point of view, think we discussed this sometime back within Beskar
but basically the idea should be to have Claude generate your tests and be very thorough

29:39.563 --> 29:46.476
with it, review them, and essentially ensure that they're testing the right set of things.

29:46.629 --> 29:59.016
there is this whole argument of classist versus mockist sort of testing and essentially
ensuring that you're not actually testing you should be testing your the values and

29:59.016 --> 30:00.237
function returns

30:00.661 --> 30:08.081
rather than going and testing that the function is calling another, making another
function call with an object within it, sort of a thing.

30:08.101 --> 30:12.061
basically, good tests are important.

30:12.521 --> 30:14.681
So spend time reviewing that.

30:14.681 --> 30:21.041
And then ask Claude to pass those tests with, do the red-green refactor.

30:21.041 --> 30:23.241
Make that a skill, sort of thing.

30:23.241 --> 30:28.861
So the whole red-green refactor implementation could be a skill, a workflow, where

30:28.935 --> 30:39.914
you it generates a set of tests for you you review those tests and then you invoke a skill
to kind of say okay hey you have this sort of test go ahead and write code to pass them.

30:40.194 --> 30:41.005
interesting.

30:41.005 --> 30:42.265
Okay, cool.

30:42.265 --> 30:42.575
Cool.

30:42.575 --> 30:43.557
I hadn't thought of that.

30:43.557 --> 30:46.047
So, okay, but let's see, let's get beyond the test suite.

30:46.047 --> 30:51.399
Let's get beyond like integration testing and unit testing and sort of the literal QA,
right?

30:51.399 --> 31:01.267
And so for instance, personally, I'm still desk checking work, you know, like when,
especially if it's like an experience improvement.

31:01.267 --> 31:02.327
Like I want to look at it.

31:02.327 --> 31:07.260
I don't want to just tell Claude, like make the experience better in the following ways
and just cross my fingers.

31:07.260 --> 31:08.790
You know, I want to see it.

31:08.790 --> 31:12.722
want to, you know, on, some level that helps me feedback into product design.

31:12.722 --> 31:14.884
You know, that's where some of the creativity happens.

31:14.884 --> 31:26.491
so how are you seeing that change in terms of like how you interact with UI And how do you
like the manual testing, the error guessing, you know, sort of the, the, the, the actual

31:26.491 --> 31:26.941
active quality.

31:26.941 --> 31:28.824
quality assurance, not just the test suite itself.

31:28.824 --> 31:30.205
That's an interesting question.

31:30.205 --> 31:34.928
I've not actually seen tools come across tools that can actually solve that problem.

31:34.928 --> 31:39.741
I think you still rely on Selenium or tools.

31:39.741 --> 31:40.872
What is the...

31:42.152 --> 31:43.013
Playwright, yeah.

31:43.013 --> 31:44.175
Playwright tools like that.

31:44.175 --> 31:50.079
But yeah, I think you can still use Claude or Codex or coding agents like that to...

31:50.277 --> 31:52.850
invoke those tests, but it's a good point.

31:52.850 --> 31:57.988
basically how would you, I don't know, like I'm not, they've not done that sort of thing.

31:57.988 --> 32:04.181
think mostly there are still automatable wire coding agents, I would say.

32:04.181 --> 32:04.562
Nice.

32:04.562 --> 32:06.183
like, I like you're sticking to automation.

32:06.183 --> 32:07.012
Like I like it.

32:07.012 --> 32:07.665
That's a good thing.

32:07.665 --> 32:08.166
Okay.

32:08.166 --> 32:09.948
What about so integration?

32:09.948 --> 32:17.555
What about the, and, on, and on some level, think integration here, I mean, obviously you
continuous integration, continuous delivery, those kinds of things.

32:17.555 --> 32:21.709
But I think also just the literal sort of act of integrating multiple code bases.

32:21.709 --> 32:22.722
Like if you.

32:22.722 --> 32:31.683
suddenly need to start using an API service that's part of one of your enterprise
customers that you didn't use before, you know, and now you need to integrate with it and

32:31.683 --> 32:32.374
you weren't before.

32:32.374 --> 32:40.034
Like, that sort of literal act of integration in as much as like continuous integration
and builds and all that.

32:40.034 --> 32:41.935
Yeah, what are you seeing changed there?

32:42.187 --> 32:44.591
I think it's kind of remained the same.

32:44.591 --> 32:49.216
basically, mean, sorry, could you kind of repeat the question?

32:49.444 --> 32:51.456
it's an awkward question.

32:51.456 --> 32:58.587
keep trying to, I'm maybe trying to conflate multiple things, but I think of it this way,
like Kroger Pharmacy, right?

32:58.587 --> 33:03.789
One of the things that they had to do was integrate with an existing enterprise database.

33:03.789 --> 33:09.081
You know, and they couldn't really change it, you know, and that was always one of the big
risks for that project.

33:09.081 --> 33:13.093
You know, we kind of knew like, yeah, here's the PRD for this code that we have to write.

33:13.093 --> 33:19.156
We're going to write it, you know, and we're going to write, you know, the, backend and
we're going to write the UI and they're going to talk to each other.

33:19.156 --> 33:28.020
So there's not a lot of integration risk because we're coding the backend and we're coding
this, but we also needed to talk to this other thing over here that we could not control.

33:28.020 --> 33:33.724
And so I kind of mean that when I'm saying integration right now, you know, the, the act,
the literal act of integrating was something

33:33.724 --> 33:41.862
and not just sort of integrating code that, you know, person A and person B on the same
team wrote, but like integrating with stuff which is external to you.

33:41.862 --> 33:43.885
Like, has it changed any of that?

33:44.136 --> 33:45.776
I don't think there's a lot that has changed.

33:45.776 --> 33:48.156
You still rely on your contract testing.

33:49.036 --> 33:52.076
basically, I think it's become very easy to mock things out.

33:52.076 --> 34:02.136
Like if you had to, I just generate a mock that maybe meets this sort of, if you have like
swagger docs, just generate mocks.

34:02.316 --> 34:12.716
And I think there are some third party services that support that, but building something
like that in-house has become so easy that you can.

34:12.925 --> 34:17.262
I mean, in fact, that's true for a lot of other things as well, if you want to.

34:17.262 --> 34:17.623
Yeah.

34:17.623 --> 34:18.358
So I think.

34:18.358 --> 34:26.080
that just reading that swagger, it's gonna go from here's the swagger URL to here's a
working client so fast.

34:26.080 --> 34:33.368
So yeah, think it does speed, just inherently, just its ability to read documentation
speeds that up quite a bit.

34:33.368 --> 34:34.044
Yeah.

34:34.044 --> 34:34.993
yeah, absolutely.

34:34.993 --> 34:39.096
might not necessarily see that there is like a different paradigm on the other side of
that.

34:39.096 --> 34:47.553
Like it might just sort of create a mapper and not very thoughtfully convert our object to
their object or something like that and not really realize that, this, ugh.

34:47.553 --> 34:51.257
So I still think you need to like think through the domain a little bit with it.

34:51.257 --> 34:55.840
But the literal act of reading a swagger and building a client, like it can do that
incredibly quickly.

34:55.840 --> 34:58.021
Yeah.

34:58.021 --> 34:58.922
Cool.

34:59.540 --> 35:03.001
What about when it comes to deployment and infrastructure?

35:03.001 --> 35:04.584
Are you seeing any changes there?

35:05.250 --> 35:14.313
We actually, I was heavily involved in getting infrastructure automated for one of the
previous clients and Claude did a fantastic job.

35:14.333 --> 35:17.355
He used Terraform and Terragrunt mostly.

35:17.355 --> 35:23.348
I read somewhere that these coding agents are not really good at coming up with an initial
cut.

35:23.348 --> 35:24.134
uh

35:24.134 --> 35:26.785
from a code quality standpoint that they're not great.

35:26.785 --> 35:33.048
And you have to tweak and tune and set it up properly for it to do a good job.

35:33.048 --> 35:37.090
for IAC, I saw that it was actually doing a really good job.

35:37.090 --> 35:44.354
Like basically it broke things down into modules, stacks, and that TeraGrunt configs for
every environment.

35:44.414 --> 35:45.424
That was so neat.

35:45.424 --> 35:49.020
Like basically, I think it was very kind of.

35:49.020 --> 35:50.500
nice to work with.

35:50.540 --> 35:57.660
something that would have taken like a week or two weeks, you can kind of do it in two
days.

35:57.800 --> 36:06.220
So yeah, I mean, it really works beautifully with infrastructure as code And it kind of
makes it easy to test it as well.

36:06.580 --> 36:12.678
So one of my things, and I think this is mostly from Sharan his...

36:12.678 --> 36:15.841
Go to tool for any kind of build activity is make, Makefile right?

36:15.841 --> 36:25.199
So you kind of put everything in a Makefile and any kind of build or test or integration
test, or run anything, you do it via make.

36:25.340 --> 36:34.428
And I asked, I kind of put that as a guardrail and so you can just say make TF plan or
make TF plan this particular stack of services.

36:34.428 --> 36:37.571
And it doesn't really, I mean, it just goes ahead and does that.

36:37.633 --> 36:43.395
So yeah, mean, it's really crazy how efficient you can be in building some of these
things.

36:43.395 --> 37:00.191
yeah, so it does understand terraform I mean, again, you can actually inform about various
environments and which AWS profile to use for which environment and configs like that.

37:00.191 --> 37:01.557
You can put that in your Claude.md

37:01.557 --> 37:07.997
You just have to ensure that the right set of instructions are in place, then it's your
buddy can actually do lot of things for you.

37:08.078 --> 37:09.540
nice, yeah, totally.

37:09.540 --> 37:14.004
I normally ask about debugging next, but you already talked about that, and I agree with
you, it's incredibly good.

37:14.004 --> 37:16.010
Refactoring, we've already covered.

37:16.010 --> 37:17.421
uh dependency management.

37:17.421 --> 37:19.014
Are you seeing anything there?

37:19.014 --> 37:27.338
I have a team right now that's got a dependency on Quarkus, you know, and it's a little
bit out of date and now it's time for them to go update it, you know, and they're going

37:27.338 --> 37:35.072
through the motions of making that safe, you know, and so that kind of dependency
management maybe if you've taken a dependency on a framework and you now need to update

37:35.072 --> 37:35.242
it.

37:35.242 --> 37:41.735
But of course, we're also seeing like Shai Hulud and the recent worms kind of running
through uh

37:41.735 --> 37:44.958
GenAI tooling and all of this.

37:44.958 --> 37:48.200
How are you thoughtful about dependency management these days?

37:48.233 --> 37:58.293
I mean, in the projects that I've worked on, we've not done anything special apart from
using a skill just to ensure that you're on the latest version or, know, like basically

37:58.293 --> 38:05.614
ensuring that, I mean, actually with vulnerabilities, AWS itself does a good job, right?

38:05.614 --> 38:16.514
Like, because you get those alerts and they run these scans that tell you that you're
using a package that is actually has this vulnerability.

38:16.653 --> 38:28.852
So yeah, think writing a workflow, I mean, you can do these hooks as well with Cloud,
where you can say that, hey, uh this part of the code base is kind of sensitive.

38:29.253 --> 38:37.681
basically, if anything changes there as part of a commit, I want you to run this script
just to ensure that the dependencies are in order and things like that.

38:37.681 --> 38:39.864
I can think of those kinds of ideas.

38:39.864 --> 38:41.406
But yeah, basically,

38:41.406 --> 38:48.703
Some of these things can be built into the Claude tool set just to ensure that you're on
the latest possible version.

38:48.703 --> 38:49.023
Yep, 100%.

38:49.023 --> 38:53.328
Okay, so in you working

38:53.328 --> 38:59.661
Working at a company that focuses on custom software development for clients, think this,
and you've kind of hinted at this earlier, right?

38:59.661 --> 39:02.294
You started to say like, you need fewer developers.

39:02.294 --> 39:08.757
So, but a question I often ask is, what are you noticing about team roles and team ratios,
right?

39:08.757 --> 39:15.381
Like in the old days, we might've said like, six pairs of developers, you need two BAs and
you need one QA, you know?

39:15.381 --> 39:19.383
that wouldn't be work for everything perfectly, but that was a decent,

39:19.383 --> 39:21.464
you know, get started template.

39:21.784 --> 39:24.905
What are you seeing these days for like ratios?

39:24.905 --> 39:33.649
Do we need more of a certain role and less of like fewer developers like you've said, but
what other impacts are you seeing on teams and how they get built?

39:34.273 --> 39:48.014
Yeah, so I think more of like basically you need somebody who is good at design and who is
kind of good at system design, architecture, somebody who's a senior developer and like a

39:48.014 --> 39:52.830
bunch of mid-level developers who can actually use Claude code effectively, right?

39:52.830 --> 39:55.251
Guided by the senior team member.

39:55.251 --> 39:56.170
So, I mean,

39:56.170 --> 40:07.734
Yeah, like basically I think for junior developers especially it according to me it looks
like it's going to be a problem because Claude Code can act as one of your junior dev

40:07.734 --> 40:13.916
pairs where it guided in the right kind of way, can do a lot of things for you.

40:13.916 --> 40:20.820
I think that's where teams mostly will cut costs in kind of hiring freshers or

40:20.839 --> 40:21.301
Yeah.

40:21.301 --> 40:22.762
lot of experience.

40:22.762 --> 40:25.635
there are still things to figure out there.

40:25.635 --> 40:36.478
Like for anybody who wants to enter the IT industry right now, it's going to be very
difficult because you have something that's solving a lot of the problems that they would.

40:36.478 --> 40:38.300
And people are being productive as well.

40:38.300 --> 40:39.948
So the entry barrier is high.

40:39.948 --> 40:42.690
Yeah, yeah, getting higher.

40:42.751 --> 40:44.774
Yep, yep, agreed, agreed.

40:44.774 --> 40:46.616
Okay, but what about other roles?

40:46.616 --> 40:50.429
earlier when I was asking about testing, leaned into we automate everything.

40:50.429 --> 40:54.103
So I'm not hearing a lot of like, we have more QAs because there's more software.

40:54.103 --> 40:55.484
Okay, I'm not hearing that.

40:55.484 --> 40:55.956
But.

40:55.956 --> 40:57.999
Are you hearing anything around like product management?

40:57.999 --> 41:01.204
Do you need more access to SMEs, Subsect Matter Experts?

41:01.204 --> 41:05.409
Do you need more access to product management to answer questions?

41:05.409 --> 41:09.576
Or does that mean that you need differently shaped developers that can sort of do that on
their own?

41:09.576 --> 41:12.959
how is it impacting like the other roles on the team?

41:13.223 --> 41:23.199
Yeah, definitely from what I've seen, There is a need for developers to think more from
the product angle because a lot of the implementation has been taken off their hands,

41:23.199 --> 41:23.439
right?

41:23.439 --> 41:33.327
So essentially, product managers and somebody who can guide or have a clear vision and
roadmap for a product, that becomes really important.

41:33.327 --> 41:37.890
I think the term is product engineers, I really don't like actually.

41:37.890 --> 41:40.052
But I prefer software engineers.

41:41.193 --> 41:42.768
yeah, that's kind of beginning to.

41:42.768 --> 41:44.257
I mean, with this whole thing,

41:44.105 --> 41:53.049
I've actually gone through some sort of an existential crisis, to be honest, where you
kind of think what the hell is going on and where is this all headed, sort of thing.

41:53.230 --> 41:59.391
I think we are headed where people need to start thinking product more.

41:59.391 --> 41:59.757
Yeah.

41:59.757 --> 42:01.987
product engineer thing is really kind of happening.

42:02.236 --> 42:02.966
Yeah.

42:03.217 --> 42:04.078
Yeah, a hundred percent.

42:04.078 --> 42:11.438
I keep telling people, I don't know if I'm right, but the thing that I keep telling people
instinctually is talk to Claude about the domain, right?

42:11.438 --> 42:15.898
If this is quick service restaurants, talk to Claude about the hamburgers, right?

42:15.898 --> 42:17.738
Talk to Claude about the point of sale system.

42:17.738 --> 42:20.118
Talk to Claude about, talk to it about the domain.

42:20.118 --> 42:23.038
Don't talk to it about the curly braces and where to put them.

42:23.038 --> 42:24.458
It doesn't make any sense.

42:24.458 --> 42:29.678
The more it knows about the domain, the smarter it's going to be at writing software for
you.

42:29.678 --> 42:31.672
So yeah, that totally

42:31.672 --> 42:35.634
lines up with what I'm seeing, what you're talking about, that we all, you want to be
talking about it more.

42:35.634 --> 42:36.895
So that means you need to know it.

42:36.895 --> 42:37.916
You can't avoid it.

42:37.916 --> 42:48.362
You know, I feel like teams used to have sort of, you know, a developer, maybe two that
were so focused on the code and not so much focused on the actual domain.

42:48.362 --> 42:52.084
And I feel like there's less room for that person right now.

42:52.084 --> 42:52.634
Yeah.

42:52.634 --> 42:52.975
Yeah.

42:52.975 --> 42:53.705
Yeah.

42:54.072 --> 42:54.966
Yeah.

42:54.966 --> 42:55.776
Okay.

42:56.649 --> 43:02.149
So I've kind of seen that lot of people are coming up with these Claude skills, right?

43:02.149 --> 43:07.249
Like where they have their own set of roles or that sort of thing.

43:07.249 --> 43:14.449
And I've seen one of those repositories where it was really interesting where a CTO was a
skill.

43:14.789 --> 43:15.829
I mean, basically.

43:15.929 --> 43:18.649
So any feature that needs to be implemented,

43:18.795 --> 43:28.445
it has to kind of go through that and you can kind of see, you can vet with the CTO or CEO
just to kind of see if it's in line with the product vision or not sort of a thing.

43:28.445 --> 43:38.023
So like you said, basically that can be made a part of your whole code base and you can
kind of ensure that you're doing the right thing.

43:38.024 --> 43:38.618
Yeah.

43:38.618 --> 43:39.720
Yeah, you could.

43:39.720 --> 43:44.348
That could be a git hook or not a get hook or Claude hook, for instance, or git hook
either.

43:44.348 --> 43:44.909
Yeah.

43:44.909 --> 43:45.930
Ooh, I like that.

43:45.930 --> 43:46.850
Yes.

43:47.031 --> 43:47.392
OK.

43:47.392 --> 43:52.758
Has it changed how you hire staff, train, mentor when you think about those aspects?

43:53.198 --> 43:59.602
Absolutely, I think it definitely has changed the way you onboard new folks to the team.

43:59.683 --> 44:09.853
Because now you can have all of this context with the powerful features that Claude Code
have added, with memory, with skills and stuff like that.

44:10.074 --> 44:16.399
It's become very easy to ask questions about the project, the problem you're solving, as
well as the code base.

44:16.639 --> 44:17.645
Like you saying.

44:17.645 --> 44:25.094
what are we trying to solve from a business model standpoint, and how is the code based
solving the problem?

44:25.094 --> 44:28.320
And it's become very easy to ask Claude to teach you something.

44:28.320 --> 44:33.726
So you can say that, I'm new here, and just tell me how I can do this.

44:33.726 --> 44:37.934
So I've paired with an in, like a.

44:37.934 --> 44:47.587
funny side note where I've paired with ThoughtWorks folks where they kind of grab a new
developer joining a project, they just grab the keyboard and they say that, just tell me

44:47.587 --> 44:48.718
what to do and I'll do everything.

44:48.718 --> 44:53.460
I want to get ramped up on the project and that's really annoying.

44:53.460 --> 44:54.960
like gone are those days.

44:54.960 --> 44:56.497
You don't have to do that.

44:56.497 --> 45:00.823
Like Claude can be your onboarding agent and can answer all the questions for you.

45:00.823 --> 45:05.704
think onboarding people has definitely changed.

45:05.954 --> 45:06.396
Cool.

45:06.396 --> 45:07.079
Okay.

45:07.079 --> 45:09.361
How are you enabling teams with these tools?

45:09.361 --> 45:11.682
you said you're pretty stable headcount wise.

45:11.682 --> 45:17.027
So maybe you're not, you're onboarding people to projects more than you're onboarding
people to Beskar.

45:17.027 --> 45:20.948
did you go through a phase where you were kind of deciding what to do?

45:20.948 --> 45:28.803
You talked earlier about how we sat down and talked about it and we agreed that, you unit
tests should be classist not mockist and things like this.

45:28.803 --> 45:30.884
What different processes do you have?

45:30.884 --> 45:34.629
an organization around how you decide how to use these tools?

45:34.629 --> 45:37.742
Do you enable people in order to get them to use the tools better?

45:37.742 --> 45:38.973
Those kinds of things.

45:39.589 --> 45:50.428
Yeah, mostly who are joins kind of goes through, used to go through this object bootcamp
sort of thing where they learn about professional programming principles like this whole

45:50.428 --> 45:55.373
classist versus mockist or why immutability is so important, things like that.

45:55.373 --> 45:59.946
So you have sort of these really good engineering programming principles that you have to
learn, right?

45:59.946 --> 46:03.929
And I think those are still relevant to some extent.

46:04.001 --> 46:08.102
Because you as an engineer, need to learn that, according to me.

46:08.102 --> 46:11.184
My personal take is that.

46:11.184 --> 46:17.027
anybody who's joining Beskar, right now we have a set of clear opinions on what tools to
use.

46:17.027 --> 46:27.374
And when it comes to GitHub Copilot versus Claude Code way of working, how you should go
about managing context, context windows, and things like that.

46:27.374 --> 46:30.038
how you should manage your cloud coding sessions.

46:30.038 --> 46:37.467
Basically the idea is that should be able to exit a cloud coding session and enter it or
start a new session without a lot of fear.

46:37.467 --> 46:45.049
Basically it should not be like you have a huge conversation that you lose if you exit a
session.

46:45.049 --> 46:52.573
your Claude Code setup should be such that a lot of that is already built in and it's able
to pull stuff from memory pretty easily.

46:52.573 --> 46:58.417
So we have some opinions internally and I think Baid is like a result of that sort of
thing.

46:59.158 --> 47:04.561
So yeah, basically that's kind of how we are doing it right now.

47:04.761 --> 47:12.143
Interestingly, we have not actually, I mean, we have a plan, but we've not hired anybody
and we've not had the need to do that.

47:12.143 --> 47:13.634
But yeah, that's the plan.

47:13.634 --> 47:22.644
Essentially, go through an object boot camp and also this set of training sessions where
you learn about opinions on some of these things and how to use them.

47:23.652 --> 47:24.043
yeah.

47:24.043 --> 47:25.605
Maybe tell us a little bit about Bait.

47:25.605 --> 47:26.936
We kind of skipped past that, right?

47:26.936 --> 47:32.404
You guys do a lot of custom software delivery, but you also have this product, this
generative AI.

47:32.404 --> 47:38.627
Do you guys use it internally, or do you guys have customers using it, and where does it
fit in the landscape?

47:38.804 --> 47:40.775
Yeah, actually, it's still evolving.

47:40.775 --> 47:44.439
We started a podcast series recently.

47:44.439 --> 47:57.660
And uh basically, uh we have a discussion every week on new stuff that people have found
interesting in the AI space and things like that.

47:57.660 --> 48:00.936
And the way it is kind of a result of that, where we thought that

48:00.936 --> 48:04.927
Like OpenClaw, OpenClaw was a very kind of interesting development, right?

48:04.927 --> 48:11.489
So the idea of a Bait, like the Bait bot, we call it Bait bot, and that's one aspect of
it.

48:11.489 --> 48:21.152
But the idea is to build this autonomous bot that you can chat with from WhatsApp or
Slack, which can help a team member, which can act as a personal assistant to a team

48:21.152 --> 48:21.952
member.

48:22.252 --> 48:27.989
So there is a a lobby bot that helps you onboard.

48:27.989 --> 48:35.089
you know, to Bayport and then you can ask it to be your personal assistant.

48:35.089 --> 48:42.049
So you can kind of say that I'm a DevOps engineer, I want to kind of monitor that this
particular service is behaving properly, just go ahead and do it.

48:42.049 --> 48:50.449
And you can chat with it from WhatsApp, can kind of say from Slack, you can kind of add it
and say that I want to do this.

48:50.449 --> 48:54.309
So it's controlled actions with persistent memory.

48:54.677 --> 48:59.397
So essentially, have a bunch of these agents that specialize in things.

48:59.477 --> 49:02.537
And they can help you do day-to-day work.

49:02.537 --> 49:06.297
They can do things like that.

49:06.297 --> 49:14.377
the idea is to also try and see if we can build proxy team members.

49:14.377 --> 49:16.737
So let's say you're not able to attend a meeting.

49:17.329 --> 49:18.879
your proxy does that, right?

49:18.879 --> 49:24.891
And that proxy agent has all your context because it has all the conversation history.

49:25.111 --> 49:26.993
So it kind of knows you as a personality.

49:26.993 --> 49:32.985
essentially with OpenFlower, there's this concept of a soul for every bot, right?

49:32.985 --> 49:40.008
So we are kind of going with the same kind of approach where every soul in the team,
basically every team member has a soul.

49:40.008 --> 49:43.657
And then you kind of can make, I mean, this is just a...

49:43.657 --> 49:49.002
theory that we want to start, but it can take notes for you and then action items can be
passed on to you or things like that.

49:49.002 --> 49:59.481
So the bot can attend the meeting and I think Granola is a startup that's solving a lot of
these problems around meetings where it can take notes and stuff like that.

49:59.481 --> 50:05.845
But our idea is to extend that and make it more interesting.

50:05.845 --> 50:09.869
like if you had a, if it's a meeting where you're doing a technical

50:10.241 --> 50:21.885
architecture review and you want to quickly ask, I mean you've been having these recurrent
meetings and you want to kind of go back in time and figure out why you decided on a

50:21.885 --> 50:22.727
certain path.

50:22.727 --> 50:29.174
You can ask this bot for it and say hey babe by the way tell me why we chose to do this or
whatever.

50:29.174 --> 50:30.681
So that's the general idea.

50:30.681 --> 50:36.226
to your point, if your entire job is going to meetings, then one of these meeting note
taker AIs is very helpful.

50:36.226 --> 50:40.409
But if your job is composed of many things, then it's less helpful.

50:40.409 --> 50:44.443
So this kind of ties that together with anything else that you might have asked it to do.

50:44.443 --> 50:45.143
that's cool.

50:45.143 --> 50:47.675
OK, now I want to use Bait.

50:47.926 --> 50:49.849
Yeah, mean, it's still in beta.

50:49.849 --> 50:52.532
We're still trying to, still testing it out.

50:52.532 --> 50:54.896
But as soon as it's out, I'll you know.

50:54.896 --> 50:55.456
Yeah.

50:55.456 --> 50:59.531
No, definitely I'll appreciate your feedback on some of this.

50:59.531 --> 51:05.296
so we are, I definitely appreciate your time today and we are coming close to the end.

51:05.296 --> 51:12.251
There's three more questions I wanna ask and these are kind of getting more into personal
and less about the generative AI.

51:12.251 --> 51:17.375
In fact, the first question I'm gonna ask is something you've had to change your mind on,
right?

51:17.375 --> 51:19.296
Or something that was unintuitive.

51:19.483 --> 51:22.427
And so far, almost every guest has said, I was wrong about AI.

51:22.427 --> 51:24.320
I didn't think it would be as important.

51:24.320 --> 51:28.424
So, okay, that's fine, but try to think of something else also.

51:29.406 --> 51:35.093
So here's the first question, something you've had to change your mind on or that was
unintuitive at first.

51:35.937 --> 51:37.737
I was going to answer the same.

51:37.989 --> 51:39.220
Yeah, I think.

51:39.471 --> 51:42.912
You mean from an AI standpoint or just generally?

51:42.912 --> 51:44.446
light perspective, yeah.

51:44.697 --> 51:48.631
think of I mean, general life perspective, don't think of anything.

51:48.631 --> 52:00.482
But yeah, I mean, from an ESF standpoint, like I said, I've always been a skeptic and I've
always played the devil's advocate and I think Lord Code, I've definitely come around now.

52:00.482 --> 52:08.009
Yeah, it seems like and it's getting to a point where you like I've seen developers who
don't even have intelligent idea or any other idea open.

52:08.089 --> 52:09.599
All they have is terminal.

52:09.599 --> 52:11.159
yeah, that's me.

52:11.959 --> 52:13.039
yep, that's me.

52:13.039 --> 52:13.659
Yeah, it's funny.

52:13.659 --> 52:17.999
At first I thought, oh, this is like when Stack Overflow showed up.

52:17.999 --> 52:20.259
Stack Overflow felt like cheating for a little while.

52:20.259 --> 52:22.039
It was like, wow, this is great.

52:22.899 --> 52:28.919
And before that it was like internet mailing lists felt like cheating, because you didn't
have to open the manual.

52:29.170 --> 52:31.350
And at first I thought, oh, this is just like that.

52:31.350 --> 52:33.610
But I'm starting to think, no, it's much bigger.

52:33.610 --> 52:36.810
It's almost like before the internet, kind of bigger.

52:37.276 --> 52:40.417
So yeah, think, yeah, it's a good answer.

52:40.417 --> 52:40.848
All right.

52:40.848 --> 52:44.247
So next question, something you are most proud of.

52:44.499 --> 52:54.130
I think, yeah, mean, leaving the regular job sort of thing and being kind of brave enough
to go and start something on your own, yeah, I think that is something that, can be proud

52:54.130 --> 52:54.890
of.

52:56.511 --> 53:03.776
Yeah, basically to, and to start with no clients and just to kind of quit one day, not
having anything else.

53:04.029 --> 53:05.612
to have the courage to start something.

53:05.612 --> 53:08.417
Yeah, I think that's something that's interesting.

53:09.438 --> 53:11.554
what's something that's giving you joy right now?

53:11.805 --> 53:17.351
I've started gymming I have a good routine now and I'm really enjoying that.

53:17.351 --> 53:19.867
So it's both gym and running, actually.

53:19.867 --> 53:22.569
That's kind of giving me joy, apart from the work.

53:22.569 --> 53:23.349
Yeah, yeah, yeah.

53:23.349 --> 53:23.940
Yeah, of course.

53:23.940 --> 53:24.891
Of Yeah.

53:24.891 --> 53:26.872
We have to we have to do other things too.

53:26.872 --> 53:27.532
Awesome.

53:27.532 --> 53:29.574
Guru, thank you so much for being on the show today.

53:29.574 --> 53:30.373
Really appreciate you.

53:30.373 --> 53:31.535
This is great.

53:31.786 --> 53:34.026
Thanks, Kyle, fun being here

53:34.624 --> 53:34.794
Okay.
