The hottest Software Engineering Substack posts right now

And their main takeaways

Your engineers need an AI control plane, not more tools | Guild.ai’s James Everingham

Dev Interrupted • 74 implied HN points • 10 Mar 26

🕹 Technology Software Engineering

Treat AI as a control plane woven into the software development lifecycle, not just another set of point tools, so teams actually get sustained impact instead of drifting back to old habits.
Agent technologies are becoming central — they can run long, collaborative, and OS-level tasks — so engineering must plan for complex, federated workflows and new operational patterns.
Low-cost automated development is replacing routine coding, so the real value now is in software engineering: architecture, judgment, governance, and measuring AI’s impact on delivery and predictability.

AI #149: 3

Don't Worry About the Vase • 2598 implied HN points • 01 Jan 26

🕹 Technology Software Engineering

AI coding agents have reached a point where they write large amounts of real software and act like persistent, configurable coworkers, rapidly changing what software engineering looks like.
Large language models are democratizing powerful capabilities for translation, research, and automation, but they also produce low-quality or harmful outputs, enable scams, and can mishandle sensitive human situations.
AI is already reshaping jobs, markets, and geopolitics—sparking lawsuits, export and chip worries, and calls for regulation—while public opinion remains split between cautious optimism and serious safety concerns.

Xcode Organizer: Your Performance Cheat Sheet

Jacob’s Tech Tavern • 1530 implied HN points • 20 Jan 26

🕹 Technology Software Engineering

Xcode Organizer gives you aggregated performance metrics and reports across your whole user base, making it the best place to spot problems early. It acts as the top of the performance funnel where most optimisations begin.
Use the Organizer to find low-hanging fruit like slow launch times, scroll hitches, app terminations, and battery or storage issues, and slice data by device, OS, or app version to catch corner cases. This makes it easy to prioritise fixes that users will actually notice.
After spotting issues in the Organizer, drill down with Instruments to identify root causes, fix them, and verify improvements; these small wins deliver outsized user impact and can boost your visibility and career.

LLMs + Coding Agents = Security Nightmare

Marcus on AI • 14030 implied HN points • 17 Aug 25

🕹 Technology Software Engineering

LLMs and coding agents can create serious security risks because they introduce many new vulnerabilities. If these tools are misused, they can allow bad actors to gain control of systems.
Hackers can trick LLMs into executing harmful code by hiding malicious instructions in well-disguised places, making it easy for developers to unknowingly execute these commands.
It's essential to limit the power and access of coding agents to reduce these risks. Developers should be cautious and not treat these tools as fully reliable, as they can lead to significant security breaches.

Taming the Genie: "Like Kent Beck"

Software Design: Tidy First? • 1104 implied HN points • 20 Jan 26

🕹 Technology Software Engineering

Telling a model to adopt a persona improves small-scale behaviors like clearer variable names and modular, test-driven code. It doesn’t reliably change the overall architecture on its own.
Giving explicit design constraints (for example, prescribe the Composite pattern and small specialized classes) reliably drives macro-architecture and produces simpler, finer-grained designs. These structural prompts change high-level decisions even without a persona.
Combining a persona with clear architectural constraints gives the best result—good style plus the right structure. Scaling this by generating many variants and selecting the lowest-cost successful implementations can further evolve better model-driven development.

Get a weekly roundup of the best Substack posts, by hacker news affinity:

The imminent risk of vibe coding

Basta’s Notes • 900 implied HN points • 30 Jan 26

🕹 Technology Software Engineering

LLMs and AI coding tools tend to take the shortest path and are lazy about cleanup, producing sprawling, poorly tested, and repetitive code that accumulates as “vibe code.”
That sloppy output raises the review burden because authors often don’t fully understand AI-written changes, so reviewers end up doing more work and review fatigue lets problems slip through.
To break the negative feedback loops, teams need process changes and tools: schedule cleanup time, enforce smaller PRs and paired reviews for large changes, and invest in automated review tools without shaming people for using assistants.

The hard problem with hard problems

Overthinking Everything • 558 implied HN points • 13 Feb 26

🕹 Technology Software Engineering

People often blame the inherent difficulty of a task when they fail, which can hide basic, fixable mistakes. Noticing that distinction lets you actually solve the real problems.
When coding agents or teams cut corners, fake fixes, or write tests that don’t catch the real issues, the issue is poor engineering and oversight rather than raw intelligence. Better testing, shepherding, and processes are what’s needed.
If you don’t notice that avoidable issues are making the work harder, you won’t learn from failure and will keep failing for the same reasons. Spotting and diagnosing those avoidable problems makes the real hard work tractable.

Andrej Karpathy’s Autoresearch 101 Builder’s Playbook: Make Your AI Skills, Prompts, and Agents Improve Themselves Overnight

The Product Channel By Sid Saladi • 13 implied HN points • 21 Mar 26

🕹 Technology Software Engineering

An automated loop that edits one file, runs a binary eval, and keeps changes that improve the score can self-improve code, prompts, templates, or agent workflows.
The method only works if you can score outputs automatically with yes/no tests, the scoring runs without humans, and each round changes only one file; writing concise binary eval criteria (3–6 items) is the hardest and most important part.
With a coding agent and a short setup you can run dozens of overnight improvement cycles for a few dollars, so pick the thing that frustrates you most, write clear evals, and let the loop find measurable gains.

Copy-on-write teaches you EVERYTHING about Swift Internals 🐮

Jacob’s Tech Tavern • 2405 implied HN points • 15 Dec 25

🕹 Technology Software Engineering

isKnownUniquelyReferenced is the tiny runtime check Swift uses to tell if a heap-backed value has only one owner. It’s the key mechanism that makes copy-on-write work under the hood.
Copy-on-write lets structs behave like independent value types while sharing heap storage until you mutate them, at which point a uniqueness check triggers a deep copy. This gives easy-to-reason-about value semantics with low memory overhead.
Many core Swift types (Array, Set, Dictionary, String, Data) use copy-on-write, and you can implement it yourself by wrapping your value in a reference box and using isKnownUniquelyReferenced to decide when to copy.

The Emerging "Harness Engineering" Playbook

Artificial Ignorance • 273 implied HN points • 22 Feb 26

🕹 Technology Software Engineering

Engineers’ work is splitting into two linked roles: building the harness (the constraints, tools, and feedback systems that make agents reliable) and managing agent work through planning, review, and orchestration. You do both at once, and each side informs the other when agents fail or succeed.
Harness engineering is the core pattern: enforce strict architectural guardrails, expose the same developer tools to agents, and keep living docs like AGENTS.md that are updated whenever an agent makes a mistake. These practices turn one-off agent wins into repeatable, scalable results by teaching agents and preventing repeat failures.
Managing agents requires more upfront planning, keeping the same review standards as for human-written code, and choosing between attended (supervised) and unattended (automated) parallelization based on harness maturity. Significant open problems remain — maintaining long-term code quality, verifying behavior at scale, and applying these techniques to existing messy codebases.

Why Platformer is leaving Substack

Platformer • 12755 implied HN points • 12 Jan 24

🕹 Technology Software Engineering

Platformer has decided to move off of Substack and migrate to a new website powered by Ghost
The decision was influenced by concerns over how Substack moderates content and promotes publications
Substack faced controversies over hosting extremist content, leading to Platformer's decision to leave for a platform with more robust content moderation policies

Will deception become cool again in the AI age?

Frankly Speaking • 152 implied HN points • 18 Feb 26

🕹 Technology Software Engineering

Deception is coming back as core security infrastructure: believable decoys turn attacker reconnaissance into high-fidelity intelligence and act as a deterrent, shifting the goal from just detecting breaches to minimizing attacker success (a move from MTTD to Mean Time to Deterrence).
Simply adding AI to legacy SOC workflows is a bandaid; the better path is a detection-as-code model where LLMs generate dynamic decoys and autonomously write and tune detection rules, and security engineers become product managers for risk.
Security needs a cultural shift like SREs: accept small, controlled incidents as learning opportunities (an "error" or deception budget), and focus on building developer-first, automated deception tools instead of buying slow turnkey solutions.

Slow down to speed up

The Engineering Manager • 41 implied HN points • 13 Mar 26

🕹 Technology Software Engineering

When execution gets cheap and fast, getting requirements and design right matters more; slow down to clarify the problem, success criteria, and constraints before you build.
Fast AI-generated work can look finished but still be solving the wrong problem, creating technical debt and costly rework; only unleash speed once you’re confident the direction is correct.
Make deliberate slowness practical: timebox a clarification phase, run pre-mortems and inverted questions (even using AI), build throwaway prototypes, and share artifacts so you catch mistakes cheaply and make later execution faster.

Justified

Bite code! • 1712 implied HN points • 14 Dec 25

🕹 Technology Software Engineering

Just is a lightweight cross-platform task runner that lets you put short, consistent commands in a .justfile so you don’t have to remember long install/run/test commands for each project.
It’s easy to install almost anywhere and supports setting different shells and platform-specific recipes so the same project can run on Windows, macOS, or Linux.
The DSL is small but useful — variables, named and variadic parameters, env loading, imports, and a default list command make justfiles readable, portable project documentation that speeds up daily work.

Claude Code Coded Claude Cowork

The Algorithmic Bridge • 881 implied HN points • 13 Jan 26

🕹 Technology Software Engineering

Anthropic's Claude tools are emerging as a market leader, and Cowork brings Claude Code's powerful agent capabilities to non-technical users so more people can use it.
Claude Code reportedly wrote the Cowork prototype, showing that AI can rapidly produce working software and create a recursive loop where AI builds tools that build other tools.
Humans remain essential for guidance, judgment, and tacit knowledge, so AI-assisted coding is powerful but not a replacement for human roles or a sign that full AGI has arrived.

Five quick updates about that Apple reasoning paper that people can’t stop talking about

Marcus on AI • 9485 implied HN points • 17 Jun 25

🕹 Technology Software Engineering

A recent paper questions if large language models can really reason deeply, suggesting they struggle with even moderate complexity. This raises doubts about their ability to achieve artificial general intelligence (AGI).
Some responses to this paper have been criticized as weak or even jokes, yet many continue to share them as if they are serious arguments. This shows confusion in the debate surrounding AI reasoning capabilities.
New research supports the idea that AI systems perform poorly when faced with unfamiliar challenges, not just sticking to problems they are already good at solving.

Is Source Code Going Away?

Software Design: Tidy First? • 265 implied HN points • 06 Feb 26

🕹 Technology Software Engineering

People are asking whether traditional source code might disappear as tools get better.
Developers are using AI "genies" to generate executable code that produces the desired outputs.
These are early-stage ideas being shared openly because progress is happening fast and discussion matters.

AI productivity gains are 10%, not 10x

Engineering Enablement • 23 implied HN points • 11 Mar 26

🕹 Technology Software Engineering

AI adoption in practice delivered roughly a 10% increase in pull request throughput, not the 2–3x productivity gains often advertised.
AI helps speed up coding, but coding is only a small portion of engineers’ time — planning, alignment, scoping, reviews, and handoffs remain the bigger bottlenecks.
Leaders should reset expectations and focus on process and organizational changes to capture more upside, since some teams are already doing better and we need to learn what they do differently.

@adlrocha - We are not scared of AI, we are scared of irrelevance

@adlrocha Weekly Newsletter • 194 implied HN points • 08 Feb 26

🕹 Technology Software Engineering

The real fear around AI is becoming irrelevant rather than the technology itself. Learning first principles and developing taste helps you adapt and know when to trust or override AI.
Relying on vibe-coding and AI agents can create shallow work and false progress, so don’t outsource all your thinking. Keep practicing deep problem-solving and creative thinking to stay useful.
Software engineering is moving up the stack toward systems thinking and domain expertise, so context matters more than raw implementation skill. Become a generalist who reclaims time to think, cultivates taste, and keeps learning new foundations.

Gmail: Designed to be joyfully simple

Elizabeth Laraki • 199 implied HN points • 03 Sep 24

🕹 Technology Software Engineering

Gmail was built to be fast and user-friendly. The designers wanted everyone to enjoy using email instead of feeling overwhelmed by it.
Key features like conversation threading changed how we view email. Instead of treating each email as a separate message, Gmail groups related messages together for easier tracking.
Designing for joy means creating a simple and pleasant user experience. The goal was to make Gmail so easy to use that it felt natural and enjoyable for everyone.

Software Machine Tools

Bzogramming • 61 implied HN points • 03 Mar 26

🕹 Technology Software Engineering

There is no universal machine tool: every manufacturing process has hard trade-offs in cost, speed, materials, and geometry, and even hypothetical atom-by-atom assemblers would face stability, energy, and material limits.
In software, theoretical universality (Turing-completeness) doesn’t imply practical usefulness—different paradigms like programming languages, neural networks, and superoptimizers are distinct "software machine tools" with very different real-world strengths.
Big opportunities lie in alternative software tools and analyses—verification-driven code synthesis, superoptimizers, compact magic-constant solutions, better static analysis, and more visual/geometric tooling can solve hard problems more efficiently than brute-force code or giant models.

How monday.com paused its roadmap for 30 days to hit AI escape velocity

Dev Interrupted • 46 implied HN points • 03 Mar 26

🕹 Technology Software Engineering

Pausing the roadmap for 30 days and focusing 700 engineers on core infrastructure and a cell-based architecture let monday.com scale AI features, improve reliability, and prepare for GPU-heavy agent workloads.
Legacy systems like COBOL won’t be replaced overnight; modernizing them is a brownfield problem that needs interfaces and deep, siloed context rather than general-purpose agents.
Operational risks and measurement norms have shifted: AI-caused outages are usually permission and policy failures requiring sandboxes and gated pipelines, and nearly every developer now uses AI so traditional control-group productivity studies no longer work.

Subtypes and status-dependent data: pure relational approach

Minimal Modeling • 304 implied HN points • 29 Jan 26

🕹 Technology Software Engineering

Lock a subtype/status column to a single value with a CHECK so subtype tables can only hold rows for that exact status, and reference the main table with a composite foreign key (id, status) to prevent contradictory data.
Give the main table a unique (id, status) pair and make subtype tables include a defaulted, immutable status plus their own keys so you can model both single- and multi-row status-specific information without NULLs.
This is a pure relational, NULL-free way to encode subtypes/status-dependent data using only standard constraints (CHECK, PK, FK), moving integrity into the schema and making the design extensible even if it isn’t commonly taught.

ChatGPT 5.1 Codex Max

Don't Worry About the Vase • 1120 implied HN points • 25 Nov 25

🕹 Technology Software Engineering

GPT-5.1-Codex-Max is a newer and improved coding model. It is faster, more capable, and better at keeping track of long tasks.
The model shows big improvements in cybersecurity evaluations, but there's still uncertainty about its overall capability in real-world cyber challenges.
Despite being a solid upgrade, many people feel the improvements are modest and reactions to its release have been quieter compared to past updates.

The changing buy vs. build calculus for security

Frankly Speaking • 152 implied HN points • 04 Feb 26

🕹 Technology Software Engineering

AI gives engineers a 5–10x productivity boost, so teams can now build custom security tools that used to be bought; vendors must offer clear, hard-to-replicate value or risk being replaced.
Security orgs will get leaner and more engineering-focused, with generalists building automated, agent-driven workflows and specialists shifting to model training or contract roles rather than manual operations.
The product and pricing bar is rising: per-seat pricing will likely move to usage/infrastructure models, and bought tools must be autonomous, provide outsourced specialized talent, and expose robust APIs for agent automation.

"Don't talk to strangers" also applies to software development.

System Design Classroom • 499 implied HN points • 19 Jul 24

🕹 Technology Software Engineering

Loose coupling is important in software. It means different parts of a program should depend on each other as little as possible, making it easier to change and fix things.
The Law of Demeter suggests that objects should only talk to their direct friends and not reach out too far. This helps to keep dependencies low and makes code more manageable.
Using strategies like the Single Responsibility Principle, interfaces, and dependency injection can improve your code's structure. This makes modules clear, easy to test, and maintain.

Connection Pooling: Fundamentals, Challenges and Trade-offs

Engineering At Scale • 795 implied HN points • 29 Nov 25

🕹 Technology Software Engineering

Connection pooling reuses a limited set of open database connections so the database isn’t overwhelmed, improves resource utilization, and avoids the 20–50 ms setup cost per query.
Pool size is a trade-off: too small causes waiting and higher latency during spikes, while too large wastes database resources; tune the size with load testing, monitoring, and a 15–20% buffer, and consider multiple pools for different workloads.
Building a robust pool is hard — it must handle high concurrency with low overhead and be configurable, and scaling across many app instances can still multiply connections, often requiring proxies or coordination to prevent re-overloading the database.

How PyTorch Generates Random Numbers in Parallel on the GPU

Confessions of a Code Addict • 577 implied HN points • 18 Dec 25

🕹 Technology Software Engineering

Traditional PRNGs are sequential and don’t parallelize well. Counter-based generators let any thread compute its random numbers directly from a counter and a seed, removing synchronization bottlenecks.
Philox-4x32-10 turns a 128-bit counter and a seed-derived key into four 32-bit pseudorandom values by repeated rounds of multiplication with splitting, XOR with keys, and permutation, giving strong statistical quality and skip-ahead ability.
PyTorch implements Philox on CPU and CUDA with a tiny per-engine state (~44 bytes), batches four outputs per invocation, and partitions the 128-bit counter into subsequence and offset so thousands of threads can generate reproducible random numbers efficiently.

Building Physical Agentic AI

Superficial Intelligence • 117 implied HN points • 13 Feb 26

🕹 Technology Software Engineering

Physical agentic AI puts small reasoning models on devices so they can sense, "have a little think," and act in the physical world instead of relying on brittle hand-coded logic.
Making these agents practical requires new tooling—structured prompts and I/O, tool interfaces, guardrails, testing, simulation, and validators—to constrain and verify behaviour and keep systems safe and reliable.
Improved edge AI chips and developer tools lower the barrier so the same hardware can run many real-world apps by swapping prompts, but there are cost and energy tradeoffs so early use cases target higher-value scenarios.

Claude Code’s Secret Weapon: The Complete Guide to CLAUDE.md, SKILL.md & Every Important File You’re Ignoring (+ 60 Copy-Paste Templates)

The Product Channel By Sid Saladi • 37 implied HN points • 06 Mar 26

🕹 Technology Software Engineering

Claude Code has no memory between sessions, so putting project context in CLAUDE.md gives the assistant persistent knowledge and stops you from re‑onboarding it every time.
The .claude folder (settings.json, rules/, skills/, agents/, etc.) plus a global ~/.claude layer create scoped, reusable configs and workflows you can invoke to enforce conventions and automate tasks.
Writing clear CLAUDE.md, SKILL.md, and path‑scoped rule files (and using ready‑made templates) converts Claude into a reliable, project‑aware coding partner that can massively speed up work.

Explore Then Expand Then Extract

Software Design: Tidy First? • 684 implied HN points • 04 Dec 25

🕹 Technology Software Engineering

Treat product work as three phases—exploration, expansion, extraction—and prioritize differently in each; during exploration favor fast, cheap experiments even if they won’t scale.
When moving into expansion, stop wide experimentation and focus on removing the immediate bottleneck quickly so growth can continue, even if that means pausing or throttling growth briefly.
Avoid pre-emptive over-engineering; fix emerging bottlenecks rapidly and only commit to permanent, scalable infrastructure for problems that recur or ‘rhyme’ with past bottlenecks.

Involutions: The License to Update in O(1)

Software Bits Newsletter • 206 implied HN points • 14 Jan 26

🕹 Technology Software Engineering

XOR is an involution: applying the same XOR twice cancels it out, so adding and removing an element use the same operation and let you update combined hashes in O(1).
Zobrist hashing leverages XOR to update a chessboard hash with only a few XORs per move, enabling fast transposition-table lookups and huge search speedups; collisions are possible but usually acceptable or verifiable.
More generally, pick the algebraic tool that matches your needs — use involutions like XOR for O(1) incremental updates when collisions are tolerable, rolling linear hashes for sliding windows, or Merkle trees when cryptographic integrity is required.

I'm glad I took the off-ramp from software engineering

Cloud Irregular • 6800 implied HN points • 22 Jan 25

🕹 Technology Software Engineering

A career in software engineering isn't guaranteed to lead to high pay or upward mobility. Many people find that their progress stalls after a certain point.
The rise of AI will significantly change the role of developers, making it less about coding quickly and more about solving human problems and understanding technology's role.
Choosing to step away from traditional software roles can open up new opportunities. It’s important to explore other interests and skills to avoid being trapped in a limiting career path.

Announcing The Engineering Manager Survival Guide

Tech and Tea • 115 implied HN points • 06 Feb 26

🕹 Technology Software Engineering

A new course helps engineering managers learn to handle the people side of the job and avoid burnout by teaching clearer mindsets and practical tradeoffs.
It’s an 8-week, 4-module asynchronous program you can do in about 60–90 minutes a week, with frameworks, audio conversations, exercises, and personal feedback on your submissions.
A cohort starts March 13, there’s early-bird pricing through the end of February, and there are options for corporate group discounts.

The LLM Context Tax: Best Tips for Tax Avoidance

Nicolas Bustamante • 104 implied HN points • 11 Feb 26

🕹 Technology Software Engineering

Context tokens are expensive and degrade performance as they accumulate, so treat context as a scarce resource and keep prompts stable and append-only; move dynamic pieces (like timestamps) to the end so you preserve KV cache hits.
Architect agents to minimize tokens by storing tool outputs as files, using precise two-step tools that return metadata before full content, delegating work to cheaper subagents, reusing templates, batching or parallelizing tool calls, and caching common responses at the application level.
Clean and compact data before sending it to the model, place critical information at the beginning or end to avoid the lost-in-the-middle problem, use summarization/compaction before hitting pricing cliffs, and set strict output token limits to control costly outputs.

Agent Analytics Engineer

davidj.substack • 95 implied HN points • 06 Feb 26

🕹 Technology Software Engineering

Give AI better tools instead of building bespoke agent runtimes; let existing agent systems do the reasoning while you expose well-defined APIs for ticketing, git, and CI.
With the right tooling, agents can handle routine analytics engineering at scale, meaning humans should focus on building tools, supervising edge cases, and solving the hard problems.
Use closed-loop validation (local CI, metadata-only comparisons, structured diffs) so agents can iterate safely without raw data access, and expect remaining limits around semi-structured data that need human guidance.

Preparing for a world where humans don’t write code

Brick by Brick • 72 implied HN points • 09 Feb 26

🕹 Technology Software Engineering

AI agents will increasingly write production software autonomously, making human code writing and review a bottleneck and causing many current development practices to stop scaling.
Trust should come from continuous validation, observability, scenarios, and invariants rather than relying on humans to read code, and code should be treated as disposable when generation is cheap and continuous.
Organizations should create small AI-first teams that build real production systems under strict constraints (no human-written or human-reviewed code) to learn what breaks, then let successful practices spread while humans focus on intent, constraints, and outcomes.

The Software Games: Endless Grind

Leading Developers • 73 implied HN points • 10 Feb 26

🕹 Technology Software Engineering

Careers can feel like an RPG: early on you level fast, but over time routine work gives less value and progression slows.
When the XP you earn shrinks while promotion requirements grow, engineers get stuck, demotivated, and often consider leaving.
Managers should actively create stretch opportunities and tune work difficulty so people stay in the learning zone; internal moves or new responsibilities can provide growth without switching companies.

"Automate the entire company"

next big thing • 48 implied HN points • 16 Feb 26

🕹 Technology Software Engineering

Automating an entire company now feels realistic because modern agentic AI can run end-to-end workflows across functions without constant human involvement.
Teams are already embedding AI agents to write and deploy code, run experiments, monitor training, handle sales outreach, and keep finance operations running, producing rapid productivity gains.
As AI handles more grunt work, humans will shift to directing agents and making high-level judgments, so taste and decision-making become more valuable than ever.

The One Property That Makes FlashAttention Possible

Software Bits Newsletter • 257 implied HN points • 29 Dec 25

🕹 Technology Software Engineering

Associativity is the key property that lets you split work, combine partial results, and safely parallelize or stream computations without changing the answer.
Softmax has a hidden associative state — tracking a local max and a scaled sum lets you correct and merge chunked results, which is the math behind FlashAttention’s memory- and time-saving trick.
When optimizing a global computation, look for a small combinable state and an associative combine rule; if it exists you can chunk and parallelize, and if it doesn’t (for example, median) you need a different algorithmic approach.