# Blog

> Long-form posts by László Nemes on software architecture, .NET and Java, working with coding agents, and the engineering judgement around AI.

Source: https://laszlonemes.com/blog · Author: László Nemes

Longer notes on software engineering and working with AI – written down so I have to get them right.

- October 5, 2026 · 27 min read
  
  ## Code quality in the age of AI
  
  AI didn't change what good code is – it moved the weak link from writing to review. Why the codebase is the real prompt, why two-thousand-line PRs get skimmed, what review is actually for, which checks belong in a deterministic pipeline and which to an LLM judge, why a green test proves only the size of the test data, who really writes the spec – why the relay role isn't needed, the product work gets distributed and the people-manager matters more – and how to let go of control one rung at a time. With .NET, Postgres and CI examples.
  
  `Code quality` `Code review` `AI engineering` `Coding agents` `.NET`
  
  Link: https://laszlonemes.com/blog/code-quality
- October 1, 2026 · 25 min read
  
  ## Build vs. buy, reloaded – and platform risk
  
  AI made the first version cheap, not the software: operations, integration, change and responsibility cost what they did. What you really buy (four layers, and you inherit the fourth), the seam test a demo never runs, the 90/10 trap, what a vendor learns from forty edge cases, platform risk from Exchange Basic auth to model deprecations – and why the line between build and buy is whether you can get out.
  
  `Architecture` `AI engineering` `Integration` `.NET`
  
  Link: https://laszlonemes.com/blog/build-vs-buy
- September 26, 2026 · 27 min read
  
  ## Engineering mindset in the age of AI
  
  AI took the typing, not the engineering – and the thinking is now the bottleneck. What that mindset is, how its absence looks (tool faith, green tests and red prod, best practices without their context), why AI repriced every trade-off, the difference between simple and naive, and what a junior loses when the consequences land on someone else. With migrations, three pods and an Excel export, in .NET and Java.
  
  `Engineering` `AI engineering` `.NET` `Java` `Career`
  
  Link: https://laszlonemes.com/blog/engineering-mindset
- September 20, 2026 · 22 min read
  
  ## Shadow AI and local AI: the data class decides
  
  It isn't local versus cloud: there are four levels of control, and the data class picks one. The arithmetic of running models locally, why local carries the burden of proof, the LLM provider as an adapter, what an EU region does and doesn't give you – and why shadow AI is a product problem, not a disciplinary one.
  
  `AI engineering` `Local LLMs` `Security` `Architecture`
  
  Link: https://laszlonemes.com/blog/shadow-ai-local-ai
- September 20, 2026 · 20 min read
  
  ## Loop engineering is a control problem
  
  What people mean by "loops" around coding agents, why the version that works in a team is a fifty-year-old control loop with an agent as the actuator, and how to build one from a linter, a cron job and pull requests.
  
  `AI engineering` `Coding agents` `Control loops`
  
  Link: https://laszlonemes.com/blog/loop-engineering
- September 20, 2026 · 18 min read
  
  ## Two kinds of micromonolith
  
  Microservices and Kubernetes are scaling and organisational tools, not quality tools. What splitting an application really costs, why the modular monolith is the good micromonolith, and how to build one that scales without either.
  
  `Architecture` `.NET` `Modular monolith` `Microservices`
  
  Link: https://laszlonemes.com/blog/micromonoliths
- September 20, 2026 · 18 min read
  
  ## Git and GitHub: the mental model, in pictures
  
  Almost every git confusion is a missing picture, not a missing command. The pictures: snapshots, the three areas, branches, remotes, pull requests and undo – with VS Code as the daily driver and the commands beside every button.
  
  `Git` `GitHub` `VS Code` `Fundamentals`
  
  Link: https://laszlonemes.com/blog/git-and-github