siscia

Are all the position in Microsoft WFH?

I have several friends who works in Microsoft and would disagree

That's usually what a judge decides.

Anyway, I went checking and I wasn't able to find any opening in Microsoft in the Seattle times online version. Which is definitely not a nice optics and would play unfortunately well with the current allegations

> It doesn't say anywhere that it cannot be advertised in a small town.

I think it is implies in: "The newspaper must be widely distributed in the area where the job is located."

Just to be clear, when I say that it is impossible even to self review, it was an indication of how difficult is to review code of colleagues.

Thanks so much for saying this!

Even with a single instance of Claude Code, running I am producing so much code that it is impossible to even self-review.

Can we please focus on that?

At the same time if the organisation want code fast, it gets code fast.

The revenue for a new feature today is something sure. While the cost associated with supporting such feature will be up to debate in the coming quarters.

As often it is the case, we are moving on a long vs short term trade-off space. And I don't think any experience will generalize

It seems VERY cooperative.

If you can afford that, with all the coordination costs that it comes from it, good.

An alternative is just to let the downstream service own the retry logic. Too many requests? Just error out as soon as possible.

Each team manages its budget and each other team adapts.

> If you can't spend the time to write it, why should anyone read it?

Because the value of writing are not the words on a piece of paper but the idea they convey.

Politicians speech are not worth listening too because they have a copywriter polish them?

Teacher assistant homeworks are not worth to do, because they are made by a TA and not by the course professor?

Of course there are writing as: "Hey ChatGPT write me a piece around coding with LLMs" and yeah, those are not worth reading.

But most of the writing is usually, these are the ideas, this is how the idea are structured together, now let's review them and then let's get a nice prose out of it.

Do you have specific examples of what you mean here?

It is not clear to me how the verbosity metrics works. Can someone shades more light on it?

I am building software factories and deepseek IS the workhorse.

I personally found V4-flash an amazing model and really hungry to try 4.1-flash

For software factories, cost is much more a concern that standard development workflow and using anthropic models is just a non starter

You are not wrong but if we go deeper we will find more nuances.

> tests should test behaviour and not structure.

Of what?

The whole idea of software architecture, and underlying of my messages, is to structure the code so that it is easy, but before easy, possible, to work at the right abstraction level.

Which allows to tests the behaviour of components and not their structure.

Trivial example, say your code read from a socket and manage the bytes with some CPU operations and write them to another socket. (You may recognise it is basically what a compressor do)

The way in which you manage read and write to the sockets will make dramatically simpler or much more difficult to write good tests.

If you adopt strategies like sans-io, you will see that the testing is almost trivial.

If all the logic sprawl up from the read syscall in a loop, you will notice how more challenging testing becomes.

---

To answer your question, the way I let LLMs write code is very DI (dependency injection) based.

A class never instantiates another class - all the dependencies are passed to the constructor. Including time. Including whatever DB iteraction.

The reason why I prefer this is that I can test each component at every level of abstraction. I don't have to. But I can.

My current approach is to force coverage higher than say 80% as default and then when a bug is discovered drill down to the components.

It is still early, but I find that this experiment makes little to no sense and it is barely useful.

The way you test code cannot (and should not) be decoupled by the way in which you architect the code itself.

80%+ of effective testing is not in the testing framework but in the code architecture.

The author doesn't mention how the code is being architected and managed.

For what it is worth, I found that forcing agents on DI/hexagonal architecture and forcing a trivial coverage check is quite useful and produce overall good enough code with relative little effort

It is not clear to me what the author is SPECIFICALLY against.

Only saying "LLM writing" is honestly lazy writing. Specifically what?

I get the glaring cases, I get the idea that if the prose is generated then maybe also the idea, I get the feeling when reading a complete LLM authored piece.

But that doesn't help the piece, because - beside those glaring cases - most writing today is a mix between authors ideas and LLM prose.

What breaks?

I am trying to understand in your view what are the parts that actually breaks and what kind of improvement we would need.

From one perspective I am not against lobbying in general.

The idea is that legislator don't have the full context and don't know the impact of their work - so they welcome industry or matter experts. Which is quite reasonable. I would argue that the job of the legislator is to know what they are doing, but I can see it being hard for specific technical issues that really benefits from first hand experience.

I am not even particularly against the idea of donating money to make sure a particular issue is known to the public, so that the public can make an effective voting decision.

But all of this seems quite too much.

Companies have disproportionate amount of money to donate and much less synchronization issue that citizen.

> Claude applied techniques I didn’t expect, from disciplines I wouldn’t have thought of

Do you have any example?

Lately I am finding myself doing more and more of what I called "ambient coding" so that I am not directly using anymore all of those coding harnesses.

https://redbeardlab.gitbook.io/acem/essays/ambient-developme...

I basically wrote a small GitHub app and I simply create a GitHub issue, the bot read it, run an LLM loop and come up with a PR (or a design)

Then I simply approve the pr (or the design)

I find it much calmer and much more productive

It is not clear to me how much CPU I get.

"Unlimited" as in 8vCPU and then I am billed for it on consumption?

There is a lot of positive comments in this comments section that I don't mind being a bit rough.

I think we can do much better.

The workflow of copy to chatgpt and getting feedback is just the first step, and honestly not that useful.

What I would love to see is a tool that makes my writing and thinking clearer.

Does this sentence makes sense? Does the conclusion I am reaching follows from what I am saying? Is this period useful or I am just repeating something I already said? Can I re-arrange my wording to make my point clear? Are my wording actually clear? Or am I not making sense?

Can I re-arrange my essay so that it is simpler to follow?

I think you guys are doing pretty much everything right.

Another trick that I use.

I force the code to be almost 100% dependency injection-able.

It simplifies a lot writing tests and getting the coverage. And I see the LLM being able to handle it very very well.

Yes it is passable.

Good enough that I don't review it.

Granted, it is a personal project that I care only to the point that I want it to work. There are no money on the line. Nothing professional.

I believe that part of the secret is that I force CC to run the whole est suites after it change ANY file. Using hooks.

It makes iteration slower because it kinda forces it to go from green to green. Or better from red to less red (since we start in red).

But overall I am definitely happy with the results.

Again, personal projects. Not really professional code.

What I found more useful is an extra step. Spec to tests, and then red tests to code and green tests.

LLMs works on both translation steps. But you end up with an healthy amount of tests.

I tagged each tests with the id of the spec so I do get spec to test coverage as well.

Beside standard code coverage given by the tests.

I just made an app that read GitHub issues. If they have a specific tag, the agent in the background creates a plan.

If they have another tag, the agent in the server creates a PR considering the whole issue conversation as context (with the idea that you used the plan above - but technically you don't have to.)

If you comment in the PR the agent start again loading your comment as context and trying to address it.

Everything is already in git and GitHub, so it automatically pick up your CI.

It seems simpler, but I am sure I missed something.

I am somehow close to what MSFT and GitHub are doing here, mostly because I believe it is a great idea, and I am experimenting on it myself.

Especially on the angle of automatic/continuos improvement (https://github.github.io/gh-aw/blog/2026-01-13-meet-the-work...)

Often code is seen as an artifact, that it is valuable by itself. This was an incomplete view before, and it is now a completely wrong view.

What is valuable is how code encode the knowledge of the organization building it.

But what it is even more valuable, is that knowledge itself. Embedded into the people of the organization.

Which is why continuos and automatic improvement of a codebase is so important. We all know that code rot with time/features requests.

But at the same time, abruptly change the whole codebase architecture destroys the mental model of the people in the organization.

What I believe will work, is a slow stream of small improvements - stream that can be digested by the people in the organization.

In this context I find more useful to mix and control deterministic execution with a sprinkle of intelligence on top. So a deterministic system that figure out what is wrong - with whatever definition of wrong that makes sense. And then LLMs to actually fix the problem, when necessary.

What's the hard part?