Emanuel Miranda

Software Engineer. Passionate about Agile. Guitar player. Works @ Autodoc.

[Gergely Orosz @GergelyOrosz]

Cannot help but see the concept of code reviews fading away

Talked with a rock-solid, v experienced engineer who, until recently, reviewed all code their AI generated… till Fable. And figured it’s pointless to do the review, so is stopping doing it, unless it’s for key parts of the product

And this is someone who has always reviewed their and everyone else’s code their whole career

Still unsure what to replace it with as something needs to come instead if code review!

[Pedro Tavareλ @ordepdev]

The funny thing is that people think this is a novelty. People really believe that software engineering has been changing over the past months because we're now paying attention to tests and specs. Unbelievable.

[Uncle Bob Martin @unclebobmartin]

The whole SDD (Spec Driven Design) thing is very valuable for AI development; but it carries the risk of BUFD. We'd like to avoid that. So the iterative nature of software development should be maintained. Just enough specs for the stories in this sprint -- just like we used to say that QA should write just enough acceptance tests for this sprint.

Also, we will be modifying those specs as the sprints go by. Specs will be co-authored by the humans and the AI, but with final approval, ferociously defended, by the humans.

And don't fret about the word "sprint", even if your sprint size is a day, an hour, or a microsecond, the same rules apply. Small Steps.

[Uncle Bob Martin @unclebobmartin]

For the time being AI coders will need a good working knowledge of code in order to be most effective; but that need is going to recede as the models improve. But code is the least of the skills that a good programmer needs. Problem solving, system thinking, product awareness, and structural competence have always been more important than coding; and those skills are more important than ever.

[Uncle Bob Martin @unclebobmartin]

OK, well, it's taken me two days but I now have a very robust acceptance test parser that generates coded tests from BDD statements. This parser is very specific purpose. It has deep knowledge of the internals of the system. That means the Given/When/Then statements are not abstract or obtuse. The parser knows what the regular english statements mean and generates the appropriate code.

Now I have a very complete set of acceptance tests that anchor the observable behavior of the system. Next step is to add some new behavior by first writing new acceptance tests and then making them pass. ATDD FTW.

[Uncle Bob Martin @unclebobmartin]

For years I have taught that since we spend more time reading code than writing code it is better to focus on making code readable than to focus on rushing the writing. Countless examples have shown that the latter rapidly compromises the productivity of the teams that practice it.

Lately, however, the question has been posed to me that the true revolution of AI coding may be the inversion of that principle. Color me skeptical, but willing to listen.

Is the secret of hyper productivity really to be found in the effective management of context windows?

[Uncle Bob Martin @unclebobmartin]

I am watching Claude to TDD in real time. IT write the tests, sees them fail, and then makes them pass. Glory!

[Roger Morris @realrogermorris]

The divide in software will not be between teams that use AI and teams that don’t.

It will be between teams with strong engineering fundamentals and teams without them.

Teams with clean, well-tested, modular systems absorb AI-driven change and accelerate.
Teams without those foundations collapse under faster change and compounding complexity.

Engineering fundamentals are no longer “best practices.”
They’re requirements for realizing AI’s full potential.

For a clear, practical explanation of the fundamentals that let teams learn faster and manage complexity, start with this talk by @davefarley77 👇

[Gergely Orosz @GergelyOrosz]

Unpopular option: most change that AI tools will bring for software engineers are likely to be making the practices that the best eng teams did until now, the baseline for those that want to stay competitive + move fast

Things like product-minded engineers, testing, o11y, CD etc

[DHH @dhh]

Just this past summer, I spoke with @lexfridman about not letting AI write any code directly, but it turns out half the resistance was simply that the models weren't good enough yet! I spent more time rewriting what it wrote than if I'd done it from scratch. That has now flipped.

[Boris Cherny @bcherny]

I'm Boris and I created Claude Code. Lots of people have asked how I use Claude Code, so I wanted to show off my setup a bit.

My setup might be surprisingly vanilla! Claude Code works great out of the box, so I personally don't customize it much. There is no one correct way to use Claude Code: we intentionally build it in a way that you can use it, customize it, and hack it however you like. Each person on the Claude Code team uses it very differently.

So, here goes.

[Kent Beck 🌻 @KentBeck]

Code review made sense when humans wrote code at human speed. Now I'm on a beach with a genie, generating faster than anyone could review. The old model broke. What replaces it?

https://t.co/SubVEVNl6W

New post, sponsored by @coderabbitai

[Grady Booch @Grady_Booch]

The entire history of software engineering is one of rising levels of abstraction.

This is as it was, is now, and always shall be.

[Allen Holub. https://linkedIn.com/in/allenholub @allenholub]

One of the main points of resistance to AI-Assisted Software Engineering is that many hard-won skills are not particularly useful. For example, mastery of specialized software frameworks is vastly less important. You can get by with a solid "reading knowledge." It's essential that you understand the code that an AI creates and be able to correct it, of course—that's a big part of the job—but understanding the code and writing the code are different activities (as evidenced by a lot of the code I've read that is technically proficient but demonstrates very little understanding, particularly in the architecture and maintainability departments 😄).

Too many of the frameworks we use are overcomplicated monstrosities, primarily because they've been written to handle general cases that just don't come up in practice. You need too much code to do simple things. That unnecessary complexity makes for lots of boilerplate that's pretty much the same in every system we write and wouldn't be there at all if the framework were more focused. In other words, writing that boilerplate requires writing lots of code we never use and don't want, but which must be present to keep the framework happy. A lot of the skill in using these frameworks is in learning how to handle that unnecessary complexity. The AI handles all that work for us. Not having to worry about that garbage removes considerable cognitive load from the programming process. However, we've put a lot of effort into learning all those details, so we are loath to admit that the fruits of that effort are no longer essential.

To put it bluntly, the ability to write that extraneous code that the AI now writes for us is a worthless skill. All of those resumes that do nothing but list frameworks and languages become vastly uninteresting.

What is useful, then? All the things that require thought and judgment: architecture, writing for maintainability (including naming), refactoring for simplicity and good structure, etc. We still need to know the languages and frameworks well enough to write the code, but we don't need to actually write that code, and we don't need to keep the details in our heads. The work is now more improving, structuring, reviewing, and refactoring. It's about making sure we're building something useful instead of focusing heads-down on construction. It's the fun stuff without the drudgery. I, personally, see that as a good thing.

[Snarky Puppy @RealSnarkyPuppy]

‘Somni,’ our most ambitious album to date, made possible by a team of over one hundred musicians, engineers, videographers, lighting specialists, and production crew, is finally out worldwide.
https://t.co/rkU8YCxD0O

[Tim Ottinger @tottinge]

I worked at Object Mentor (for UncleBob) when we were writing Clean Code and when SOLID was new. I taught those principles for years.
Then I worked at Progeny Linux Systems with Ian Murdock (Debian linux founder) in Python on Debian Linux.

[Bob Allen @CuriousAgilist]

1. Full-time Mob/Ensemble programming: rotating navigator, driver and mob rolls in minutes using either TDD or TCR.
2. Include visiting/borrowed expert as fixed navigator when/if needed as a guide when in unfamiliar waters.
3. Test-first (always: preferably using Gherkin and involving the product owner (to hash-out shared understanding of terms/concepts).
4. Continuous automated refactoring.
5. Add a AI as a mob member if not already built-in.

[World Mobile Chain @wmchain]

🚀 Dev Mainnet is live. And it’s already delivering.

Since June 5, over 1 million transactions have been recorded.
Real activity. Real people. Onchain.

📱 As part of the rollout, 2 million+ users are being progressively onboarded.

This isn’t a demo.
This is World Mobile Chain in motion.

🔍 https://t.co/DpLpnym1xl

[Dave Farley @davefarley77]

3 Reasons BDD Fails...

BDD is powerful when done right, but lots of teams miss the mark. In this one, I break down the 3 biggest mistakes I see in real-world teams and how to fix them.

If you've ever tried BDD and thought "this doesn't work", this is for you!