RightTech

RightTech Never worry about your companies tech again with our Virtual CTO service

More tools can make an AI workflow worse.Annoying thing to admit... but true.agentic programming is not the same as agen...
06/16/2026

More tools can make an AI workflow worse.

Annoying thing to admit... but true.

agentic programming is not the same as agentic software engineering.

Small coding tasks are one thing.

Real engineering environments are another.

Once you start wiring in lots of integrations, every tool brings overhead.

Not just in setup.

In context.

Every tool needs a description.

What it does.

How to call it.

What goes in.

What comes out.

That all eats context window.

So an agent can end up spending a surprising amount of its attention reading tool instructions...

instead of doing the actual work.

That’s the trap.

Abstractions help.

Until they start charging rent.

And in bigger engineering setups, that rent adds up fast.

Slack.

CI.

Dashboards.

Docs.

Email.

Internal tools.

Access matters.

Knowledge matters.

Tooling matters.

But if the agent can see a warehouse full of tool definitions and still miss the one thing that explains why the task exists, you haven’t really helped.

You’ve built a very informed distraction.

Good agent setup is usually not:

more tools

more servers

more definitions

It’s better structure.

Cleaner routing.

Less always-loaded noise.

The right tool at the right moment for the right reason.

Have you seen tool sprawl make an agent slower or less useful?

I used to think context windows were basically big buckets.Just keep pouring things in.Docs.Notes.Tool definitions.Extra...
06/15/2026

I used to think context windows were basically big buckets.

Just keep pouring things in.

Docs.

Notes.

Tool definitions.

Extra instructions.

Then I came across a better mental model from Daisy Hollman...

It’s not unlimited memory.

It’s closer to packing a fragile system onto tiny hardware.

If you’ve worked close to low-level systems, you’ll know the feeling.

You don’t ask, “What else can I squeeze in?”

You ask, “What absolutely needs to be here for this to work?”

That shift matters.

Especially once you move beyond simple coding tasks and into real software engineering.

A context window is just the information the model can actively work with at one time.

The mistake is treating it like free storage.

It isn’t.

Every extra thing competes with the thing that actually matters.

So the better approach is simple...

Keep the critical path.

Cut the nice-to-haves.

Be honest about what earns its place.

That mindset has improved outputs for me far more than just adding more context.

How do you decide what stays in the window?

What should go at the very front of your prompt?If context is tight and cache costs matter, this question is more import...
06/14/2026

What should go at the very front of your prompt?

If context is tight and cache costs matter, this question is more important than it looks.

One useful lesson I picked up from Advanced Claude Code educational resources was this...

Put stable shared instructions first.

Put changing task details later.

That sounds small.

It isn't.

Once you move from simple coding tasks to real software engineering work, prompt layout starts to matter a lot.

Because now you're dealing with standards, repo conventions, handoff notes, tickets, bugs, and all the mess that comes with real teams.

A practical way to think about it is simple.

If something stays the same across runs, keep it near the front.

If something changes every time, push it closer to the end.

Why?

Because the model can often reuse work from the earlier part through caching.

So when the volatile part changes, you avoid disturbing the whole prompt and burning context on things that did not need to move.

In practice, that can mean:

Team rules and coding standards at the top

Task-specific notes lower down

Fresh bug reports, tickets, or meeting notes near the end

Good prompt structure is not just tidying up...

It affects cost, reuse, and how well the system holds up when the work gets more complex.

How are you deciding what stays fixed versus what changes per task?

You probably do not need a whole new AI stack first.You probably need to show the agent the scripts your team already tr...
06/13/2026

You probably do not need a whole new AI stack first.

You probably need to show the agent the scripts your team already trusts.

That was one of the most useful takeaways I picked up from Beyond the basics with Claude Code.

Out of the box, coding agents can handle simple tasks pretty well.

But real software work is rarely just "write the code."

It is conventions.

Checks.

Release steps.

Team habits.

All the little things that make work actually ship.

Once you get into that world, the agent needs a better setup around it.

Not magic.

Just the right inputs, tools, and boundaries.

A practical place to start is with the scripts your developers already use every week.

Things like setup-dev, test-all, lint-fix, or deploy-staging.

That is usually where the real workflow already lives.

If I were setting this up, I would start here:

1. List the commands the team already relies on.

2. Mark the ones an agent can run safely.

3. Write clear instructions.
When you need X, run Y.

4. Add the expected outcome.
What success looks like.
What failure usually means.
What to try next.

5. Let the agent use those routes before building anything fancy.

That feels obvious once you see it...

But a lot of teams skip straight to designing new layers, when the useful paths are already there in shell scripts and CI.

Start with what exists.

Then build from there.

Curious if your team already has scripts an agent should be using.

Fine-tuning is not the magic fix people think it is.That was one of the clearest takeaways I got from Daisy Hollman's ta...
06/12/2026

Fine-tuning is not the magic fix people think it is.

That was one of the clearest takeaways I got from Daisy Hollman's talk, Beyond the basics with Claude Code.

It really landed for me on internal engineering knowledge.

A lot of company knowledge changes too fast to bake into a model.

Fine-tuning means training a model to pick up patterns ahead of time.

Sounds great...

Until your conventions change next week.

Or a service gets renamed.

Or a new approval step appears on Tuesday.

For straightforward coding tasks, tools can do a decent job out of the box.

But software engineering inside a real company is different.

It has local rules.

Team habits.

Naming quirks.

Release steps.

Exceptions on top of exceptions.

That is why the real challenge is not just programming.

It is working inside a living system.

The practical point from these Advanced Claude Code educational resources was simple:

Fast-moving knowledge usually belongs in context.

That means the instructions, files, and references you give the agent when the work is happening.

In a lot of cases, that is more useful than trying to train every company detail into the base model.

The split makes sense to me.

Keep the stable stuff in durable abstractions.

Keep the changing stuff close at hand.

If your conventions move every week, this is the better approach:

Keep a small, current instruction file

Link the live docs people actually use

Pass in the rules that matter for this task

Fine-tune for durable behavior.

Use in-context guidance for local change.

That split saves a lot of pain.

What have you found works when internal conventions keep moving?

A lot of engineering decisions die in a transcript folder.That is such a waste.One idea I picked up from Beyond the basi...
06/11/2026

A lot of engineering decisions die in a transcript folder.

That is such a waste.

One idea I picked up from Beyond the basics with Claude Code has been surprisingly useful...

Right after a meeting, I take the notes or transcript and feed them into Claude Code.

Then I ask a very simple question:

Is there any low-hanging fruit here you can address?

It’s one of the fastest feedback loops I’ve found.

I’ll often get two or three PRs from a single meeting.

A PR is a pull request... a proposed code change your team can review and merge.

Why does this work so well?

Because the codebase usually tells you what the system does.

It rarely tells you why a decision was made.

That part is often buried in meetings, chat, email, and design notes.

When a coding agent can see that context, the suggestions get better.

Not magic.

Just better input.

That feels more important now because software work is rarely just writing code.

It’s tradeoffs.

Constraints.

Old decisions that still shape what you should do next.

If you want to try it, keep it simple:

Record or transcribe the meeting.

Clean up the notes just enough to make them readable.

Drop them into your workflow the same day.

Start with small fixes, follow-ups, docs updates, or test coverage.

Review the PRs like you would any teammate’s work.

Simple idea...

But it turns passive discussion into action while the decisions are still fresh.

Have you tried a loop like this yet?

The shift for me was simple...I stopped treating AI like autocomplete.And started treating it like a teammate.That chang...
06/10/2026

The shift for me was simple...

I stopped treating AI like autocomplete.

And started treating it like a teammate.

That changed everything.

One of the big takeaways I got from Advanced Claude Code educational resources, especially Daisy Hollman’s talk Beyond the basics with Claude Code, was this...

The model matters.

But the setup around the model matters just as much.

That setup is the harness.

The information it can reach.

The tools it can use.

The environment it can work inside.

At first, it’s easy to think the job is just code.

Give the agent the repo and a terminal, and let it run.

That can work for neat, self contained tasks.

Then real work shows up.

The reason for the change is buried in a Slack thread.

The tradeoff is sitting in an email.

The constraint lives in a design doc.

The production issue is staring back from a dashboard.

And now the agent is not struggling because it lacks capability.

It is struggling because it cannot see what you can see.

That was the real mindset shift for me.

If the agent cannot access the context I rely on, it cannot really help at the level I need.

But when it has the same working context...

It can scale judgment, not just typing.

That’s when AI starts to feel less like a feature.

And more like a real teammate.

How are you giving your AI the why, not just the task?

Why does an AI agent look smart at 10am and completely lost by 2pm?Because at 10am it is fixing a neat little code probl...
06/09/2026

Why does an AI agent look smart at 10am and completely lost by 2pm?

Because at 10am it is fixing a neat little code problem.

By 2pm it has wandered into software engineering.

Different sport.

One thing that stood out to me from Advanced Claude Code educational resources...

agentic software engineering is not the same as agentic programming.

Out of the box, an agent with access to a repo and a shell can do pretty well on simple programming tasks.

A small bug.

A clean function.

A tidy refactor.

Nice, contained work.

Then you ask it to make a change in a real engineering environment...

Now the important information is somewhere else.

In the Slack thread where the decision got made.

In the design doc that explained the tradeoff.

In the email from the stakeholder who cares about latency.

In the dashboard showing what broke last time.

That is why this idea stuck with me: access, knowledge, and tooling.

If the agent cannot get to what you can get to, it is not necessarily bad at the task.

It is under-informed.

A lot of frustration with AI coding tools seems to come back to this:

you know the why

the agent sees the what

And the why usually does not live in the source code.

That is the gap.

Have you seen this on your team too?

The fastest agent audit I know is painfully simple...Try doing a full day of work without leaving your AI coding interfa...
06/08/2026

The fastest agent audit I know is painfully simple...

Try doing a full day of work without leaving your AI coding interface.

This is one of the most useful things I picked up from Advanced Claude Code educational resources.

Not because it is clever.

Because it shows you what is missing... fast.

Out of the box, an agent can usually see a repo and a shell.

That is enough for small coding tasks.

It is not enough for real software engineering work.

So here is the audit.

Stay in the agent interface all day.

No Slack.

No email.

No dashboards.

No docs in another tab.

Then every time you have to leave, write it down.

Be specific.

What did you open?

What were you trying to find?

What could the agent not access or understand?

Then sort each interruption into three buckets.

Access...

It could not reach the system.

Knowledge...

It did not have the rule, decision, or background.

Tooling...

It did not have the right command, script, or check.

Then count the repeats.

That is where the pattern shows up.

If you copied the same CI failure three times, that is probably an access issue.

If you kept reopening a Slack thread to remember why a change mattered, that is probably a context issue.

What I like about this idea is that it gives you a map.

You stop guessing.

You stop retyping the same context by hand.

You connect the missing source once...

Then the agent can work in a way that is much closer to how you work.

If you tried this for a day, what would show up first in your audit?

I’ve tried a lot of task trackers over the years.Monday.Asana.A few others I’ve probably forgotten.They were polished.Th...
05/24/2026

I’ve tried a lot of task trackers over the years.

Monday.
Asana.
A few others I’ve probably forgotten.

They were polished.

They were feature-rich.

They just never fit the way I actually work.

My days are pretty disjointed.

I context shift a lot.

That’s not a bug for me... it’s how I operate.

The problem was every tool seemed built for someone with a neat, linear day.

So I built a small one for myself.

Nothing huge.

Just a simple custom task tracker with a little AI agent, which is just software that can make suggestions based on rules and context.

I can drop in a task and say:

It’ll take an hour.

It’s high impact.

It’s urgent.

Then it looks at my calendar for the week, uses the prioritisation rules I’ve trained it on, and suggests where the task should actually go.

As new tasks come in, I can quite literally just tell it, and it reshuffles things around what already exists.

That ended up being more useful than all the polished software I’d tried before.

Not because it had more features.

Because it matched how I make decisions.

That’s the shift I think a lot of people are starting to see now.

Literally anyone can now build software.

The bottleneck is no longer skill.

It really is imagination at this point.

A tool does not need to be massive to be powerful.

It just needs to fit the real work.

What’s one tool you wish worked more like your brain does?

Address

9450 SW Gemini
Beaverton, OR
97008

Website

Alerts

Be the first to know and let us send you an email when RightTech posts news and promotions. Your email address will not be used for any other purpose, and you can unsubscribe at any time.

Shortcuts

Share

Category