Amit

Over a decade of experience designing and building scalable software systems. I write about backend engineering, AI, and modern web systems

[Andrew Ng @AndrewYNg]

New course: Spec-Driven Development with Coding Agents, built in partnership with @jetbrains, and taught by @paulweveritt.

Vibe coding is fast, but often produces code that doesn't match what you asked for. This short course teaches you spec-driven development: write a detailed spec defining what to build, and work with your coding agent to implement it. Many of the best developers already build this way.

A spec lets you control large code changes with a few words, preserve context across agent sessions, and stay in control as your project grows in complexity.

Skills you'll gain:
- Write a detailed specification to define your mission, tech stack, and roadmap, giving your agent the context it needs from the start
- Plan, implement, and validate features in iterative loops using a spec as your agent's guide
- Apply the same repeatable workflow to both new and legacy codebases
- Package your workflow into a portable agent skill that works across agents and IDEs

Join and write specs that keep your coding agent on track!
https://t.co/hI4GwuvhtN

[Amit @amitkdab]

Exactly.

[Siva @sivalabs]

It is very easy to misunderstand a social message 🤔

A Spring Expert says: "I haven't been writing code myself and AI is doing it for me and I am being much more productive".

That statement could be true but also has many unsaid facts supporting that:
👉 They have been working with Spring for a long time and very well familiar with it.
👉 They have hands-on experience writing code, debugging issues
👉 They have keen insights on Spring and they can review the code and spot bad code quickly
👉 They can look at an exception stacktrace and can give a ballpark idea on what could be the problem.

After having all these skills, now they are able to steer the AI agents in the right direction and became more productive 🚀

Now a junior engineer may see the original message and assume "Okay, so there is no need to learn all these nitty gritty details of the framework. I can just ask AI and I can get things done fast".

Nope...that doesn't work 🙅‍♂️

You need to learn, and understand the topic and then use the tools (IDE, AI Agents, etc) to your advantage 😎

[Arnav Gupta @championswimmer]

Author of Redis ⬇️

[Arpit Bhayani @arpit_bhayani]

One way to avoid getting overwhelmed when you are designing a system is to approach it with a structure/mental model. Here's a simple one I follow...

Think of any system as having 2 separate paths: a read path and a write path. Your database or storage layer sits at the center, and each path has its own set of problems and its own toolkit to solve them.

The write path is about durability and throughput. You are almost always choosing from the same set of levers: a message queue to absorb bursts, write-ahead logging for durability, batching to reduce I/O, and async processing to keep the critical path thin.

The read path is about latency and scale. Again, a fixed toolkit - caching at various layers (CDN, app-level, query-level), read replicas to offload the primary, denormalizing or pre-computing expensive queries, and pagination or cursor-based traversal to avoid full scans.

Once you start seeing these as two separate concerns, you stop designing a system and start answering two smaller questions: what does the write path need? What does the read path need? Then you wire them together through storage.

This 'framework' (if I can call it that) is not just useful during discussions, but also helps you reason through production systems, especially when you are building an understanding, trying to optimize an existing flow, debugging latency spikes, or planning for scale.

Hope this helps.

[Sergio Pereira @SergioRocks]

Sam Altman is right about one thing:
- Writing software used to be harder.

But there’s an assumption hidden in that statement:
- That because it’s easier now, engineers matter less.

It’s actually the opposite.

AI made it easier to write code. It did not make it easier to build robust software systems.

If anything, it made it easier to build fragile ones.

Today you can generate:
- API integrations
- User interfaces
- Backend data flows
- Entire features

In hours.

But what happens when:
- The same request is processed twice
- Data arrives incomplete or out of order
- A dependency fails halfway through
- Real users behave in unexpected ways

That’s where software breaks.

It's not about the code. It's about how the system is architected.

And that’s where engineering experience shows up.

Understanding failure modes.
Designing for edge cases.
Building systems that don’t collapse under real usage.

AI didn’t remove the need for engineers. It removed the barrier to writing code.

Which means more systems will be built. And more of them will need to be designed properly.

The engineers who can do that are not less important. They are more critical than ever.

[Amit @amitkdab]

@hellonehha 💯agree. And they are counted as resources not engineers.

[Amit @amitkdab]

@LLMJunky @sama Agree. I too use Codex most of the time, specially the App. Claude comes handy sometimes for UI work.
App is amazing. It could jump across different repos/projects to understand the code flow and came up with the detailed response. Great job!!

[Amit @amitkdab]

@LLMJunky @ajambrosino Amazing that a simple prompt is good enough for codex to do everything needed on its own!!

[Amit @amitkdab]

Amazing!!

[am.will @LLMJunky]

I'm so impressed right now.

I pointed GPT 5.4 at the Codex App Windows package last night and asked it to piece together a perfect Linux build from it.

Gave it a plan, set it to work using 20 subagents.

Woke up to this. One shot. Everything works.

[ℏεsam @Hesamation]

https://t.co/rD8OXHanSq

[Amit @amitkdab]

@claudeai Why review your own code after generation. Make it a part of the generation and fix everything before creating PR.

[Numman Ali @nummanali]

Air an Agentic Development Environment

From JetBrains - whom one upon a time I couldn't live without

Supports Codex, Claude, Gemini and their own Junie
- Through JetBrains Subscription or BYOK

https://t.co/R6sjHNldWP

[Amit @amitkdab]

Going to try them soon.

[Siva @sivalabs]

Turns out teaching the AI Coding Agents what's your preferred way of implementation(a.k.a Claude Skills) gives much better results. 😇

Took all the guidelines from my "Spring Application Architecture Design Patterns" samples and created https://t.co/0BHW6rqMl8 file and asked Claude to generate a new application.

Claude followed most of those patterns as expected 😍

Earlier I used to Vibe Code and then spend some time unvibing(cleaning up) the generated code. With these Skills given to Claude, now I no need to spend too much time for cleaning up the code. 🚀

[Amit @amitkdab]

@ajambrosino Yes please. Current dark mode is too dark.

[Amit @amitkdab]

@therealdanvega Exactly. Wrote a blog recently covering this: https://t.co/0ohsTRuDuR . Give it a read.

[Dan Vega @therealdanvega]

Code is cheap, Software is not 🤔

Anyone can write code. Building software that's maintainable, observable, secure, and actually solves a problem? That's the hard part.

This is why fundamentals matter more than ever.

[Amit @amitkdab]

@petergyang Same experience. Claude code is really amazing at UX/UI.

[Arpit Bhayani @arpit_bhayani]

Turns out companies are reimagining the entire SDLC around agents and attempting to move toward a world where engineers might not write a single line of code directly.

I was talking to an engineering leader, and it seems many companies are preparing for a fully agentic SDLC. Repositories are starting to include Claude and agent-related files, MCPs are being built for internal tools, and much more is changing. Code reviews are getting automated, among other things.

What times we are living in :)

[Amit @amitkdab]

My views on how AI will shape the field of software engineering.
https://t.co/0ohsTRuDuR

[Aakash Gupta @aakashgupta]

Every AI coding tool on earth generates Python and JavaScript instead of binary. That fact alone tells you everything about where we actually are.

Generating working binary requires solving all of these problems simultaneously in a single forward pass: CPU architecture selection (x86, ARM, RISC-V all need different instruction sets), register allocation (deciding which of 16-32 physical registers holds which value at every cycle), memory layout (stack frames, heap allocation, pointer arithmetic, alignment), system call interfaces (every OS exposes different kernel APIs), linking (resolving symbols across shared libraries at specific memory addresses), and optimization passes that current compilers handle through 50+ sequential transformation stages.

GCC’s optimization pipeline alone runs over 200 distinct passes on your code before producing a binary. Each pass depends on the output of the previous one. An AI generating binary directly would need to internalize all 200 passes as a single learned function.

For context, look at the bottom of this tweet. Researchers just published a paper on a 491-parameter transformer they trained to do 10-digit addition. A survey of 180 public LLMs found only 7% can reliably add numbers. The task being described here is to addition what landing on Mars is to a paper airplane.

Claude Code, Codex, Cursor, and every tool that actually ships production software generates human-readable code. Python and JavaScript aren’t the bottleneck. They’re the interface that lets humans verify what the AI built, debug when it breaks, audit for security vulnerabilities, and iterate when requirements change.

The compile step takes milliseconds. The part that takes hours is figuring out what the software should actually do, handling edge cases, and making sure it doesn’t break in production. High-level languages compress that problem into something a human and an AI can reason about together.

Skipping the human-readable layer doesn’t remove complexity. It hides it. And hidden complexity in software is how you get systems that work in demos and explode in production.