So it's late 2025 and to be honest I've stopped reading the
change logs. I.
Don't blame you at all, it's impossible to keep.
Up. It feels like every 5 minutes
there's a new AI coding tool, a new plug in, and it all promises
to revolutionize my workflow. I'm just feeling this massive
update. Fatigue.
It's the paradox of choice. We're drowning an option?
Exactly. So welcome everyone to the
architecture corner. Today.
We are just stripping all that back.
We're not looking at this shiny new stuff.
We're going back to the vanilla experience evolved, looking at
GitHub Copilot and VS Code and figuring out how to move from
just, I don't know, generating code to actual architectural
planning. The goal here is precision.
It's about making the tools behave, not letting them
overwhelm you. And I think the biggest shift is
how we're starting to use custom instructions.
Right, this is so much more than just the prompt.
The prompt is what one the instructions file.
That's how you want it done? The style, the principles?
Yeah, the soul of the project. Almost.
People make a huge mistake here. They just dump everything into
one giant markdown file. And that's terrible practice.
It's awful. It triggers something called
context rot. OK.
So that's tied to that lost in the middle problem.
With LM precisely, the model is great at remembering the very
beginning and the very end of your instructions.
But the stuff in the middle. It gets forgotten completely.
Yeah, If you bury your testing protocols or your naming
conventions deep inside a 2000 line file, the model basically
hallucinates that they don't even exist.
So the fix have to be granularity.
You have to break it. U you have to modularize.
Don't use one mega file. You create a tiny file just for
testing, telling it exactly which frameworks and mocks to
use. You have another one for
security. So you're only injecting the
context that's relevant for that specific.
Task. It's like a dependency injection
for your AI's brain. That's a perfect analogy.
And that way of thinking, it owes a lot to Mario Bittencourt.
He's really been pushing this idea of practical application,
not just hype. Which brings us to MCP.
The model context protocol. Right, this is the bridge to the
outside world. Because the model itself is sort
of frozen in time, right? Yeah.
If I ask for an API spec, it's gonna give me whatever it
learned during training, which could be two years out of date.
Exactly, but with MCP the AI can use tools.
Bittencourt shows a great example with a fetch tool.
Instead of guessing an API, the model literally goes out, grabs
the live open API, ARC version 3, point 2.0, whatever is
current and it codes against. That, but I see a risk there.
I mean, what if we start adding an MCP server for AW, another to
the database, another for docs? You get tool overload, the model
starts getting confused about which tool to pick, and even
worse, you open up a huge security vector.
Prompt injection. If you connect your AI to a
malicious MCP server, you've basically given an outsider a
shell you could be leaking data. So the rule is use MCP, but you
absolutely have to audit the servers you install.
That is a fair warning. OK, so let's pivot to skills.
Yeah. How is a skill different from
the instructions we were just talking?
About it's a great question. Instructions are context,
they're facts. Skills are workflows.
They are checklists, standard operating procedures.
So it's not just write code, it's follow these exact.
Steps exactly right. A skill forces the AI to execute
a specific multi step process like a web performance audit.
The skill doesn't let it guess, it has to, you know, one drop.
Run a trace 2. Analyze Core Web Vitals 3.
Check accessibility. It enforces a standard.
That creates consistency, which is huge.
But the feature that really sounds like a game changer to me
is Background Agents. Ah, this is where we solved the
human multitasking problem. Because we are just awful at
contact switching. Terrible.
But an agent isn't. You can kick off a big task, say
refactor this entire legacy module and the agent just spins
it up in a local git work. Tree, work tree.
OK, that's the key detail. So it's running asynchronously,
a totally parallel branch. It's not messing with my
current. Work exactly.
You could have one agent refactoring the back end schemas
while another one is updating the front end components to
match, all while you were working on something else
entirely. When they're done, you just
merge the work. Trees like parallel processing
for development work it. Is, but you have to remember
Bittencourt's core philosophy here.
In specs and adapt. Yeah, don't just throw out your
entire workflow because we said agents sound cool.
Test it. If modular instruction files
actually stop the AI from forgetting your testing rules,
then adopt that. If a background agent genuinely
saves you 20 minutes of context switching a day, use it, but
solve a real problem, don't just chase the tool.
That's the only way we're going to survive this fatigue.
If you want to see the diagrams and the config examples we
talked about, please do check out the description.
It's worth a. Look and for this kind of deep
analysis every week. Subscribe for free to the
Architecture Corner newsletter at
architecturecorner.substack.com. It is the best way to stay
current without burning out. Thanks for listening.
Now go clean up those markdown files.