Daniel Kristjansson

Why do LLMs seem so hell-bent on providing fallbacks? Even with rules like "no fallbacks" and "fail fast by default", they bend over backwards to avoid failure to the point where they conflate domain concepts to avoid throwing an exception.

10

18 Comments

LLMs are good at generating code that they're bad at modifying later. It'll be fine for a while, but as the code base grows beyond the usable context limit - orders of magnitude smaller than advertised - the unnecessary complexity, duplication and lack of separation of concerns will kick in. Anyone claiming otherwise has evidently never gone beyond that point using the tool. Or just hasn't noticed all the stuff that's broken. They're telling you how to run your marathon based on their experience running the 400 m.

108

23 Comments

Claude Code was asking me to approve way too many things. Every time it edited a file, I'd get a "this command requires approval" prompt. Sometimes three in a row for a single task. Turns out it was writing Python scripts and sed commands just to make simple file edits — because that's the habit it defaults to. Claude Code actually has native Edit and Write tools that bypass Bash entirely. No shell process, no approval prompt. But without explicit guidance it doesn't reach for them first. The fix is a ~/.claude/CLAUDE.md — a global instruction file Claude Code reads at the start of every session. You tell it exactly which tool to use for which job, and pre-approve a handful of safe utilities (sd, ripgrep, jq, yq) in settings.json so the ones that do use Bash don't interrupt your flow. One other thing I learned: sd (a modern sed replacement) still processes files line by line, so multiline pattern edits silently fail and Claude falls back to Python. The right call there is always the native Edit tool — which works on the full file buffer and handles multiline matches natively. Put together a Gist with the full CLAUDE.md and setup instructions if you want to steal it: https://lnkd.in/g62h4fUP The approval interruptions dropped dramatically after this. Worth 10 minutes to set up.

38

7 Comments

Is Elixir observable enough for production systems at scale? When senior and staff engineers evaluate a new runtime, the real question isn’t syntax or developer happiness, it’s operability. Can you inspect a live system under pressure? Can you correlate logs, metrics, and traces? Can you reason about failures without guesswork? I’ve published a deep-dive on the current state of observability in Elixir, aimed at engineers coming from JVM, Go, or Node.js backgrounds. It covers BEAM runtime introspection, structured logging, OpenTelemetry, Prometheus/Grafana, SaaS integrations, and, just as importantly, the trade-offs. No hype. No tutorials. Just an honest look at how Elixir actually behaves in production. 👉 Is Elixir’s Observability Ready for Production? https://lnkd.in/eSPeDNkD #Elixir #MyElixirStatus #Observability

21

AI has always been full of hype and nonsense from its beginning in the 1950s. It was actually much worse in the old times. It grew to an insufferable level in the late 1960s and until the mid 1990s. Recent publications like "Defeating Nondeterminism in LLM Inference" [1] or "Why Language Models Hallucinate" [2] are exactly that: hype and nonsense. The very term AI is a buzzword and an oxymoron -- an ephemeral fad. For the record, non-determinism in natural language is both desirable and inevitable; and so are 'hallucinations'. Everything that has to deal with beliefs and opinions cannot be sound. Thus the expression that "no one is infallible". The problem here is not the inherent nature of natural language but the fact that those companies are limited or clueless. They have adopted architectures and representations that amplify and escalate the problem. And they now suffer the consequences of their actions and their choices but they blame it on the data or the language! 1. https://lnkd.in/gH96VzVN] 2. https://lnkd.in/gda6RWpQ

19

I highly recommend reading this article on the '80% problem.' It’s a solid reality check on what it actually takes to get AI-generated code production-ready as we move toward agentic workflows. The core idea: AI gets you 70–80% done, but the last mile — debugging, integration, edge cases, security, and architecture — is still hard and requires human engineering. A few takeaways: 🔹FROM CODER TO ARCHITECT: AI doesn't replace engineering skills; it makes them more important. The challenge is moving from writing lines of code to managing architectural judgment and "comprehension debt"—areas where current AI tools still struggle. 🔹TESTS AS GUARDRAILS: Strong specifications are essential. Comprehensive tests (and TDD) act as executable specs that give AI agents the precise, unambiguous feedback they need to actually finish a task. 🔹THE DEBT TRAP: Without rigorous patterns, AI just helps us create technical debt faster. We need to guide these tools as architects, not just prompt them as users. Read the full article here: https://lnkd.in/dN7gzWE3 #GenerativeAI #SoftwareEngineering #AgenticWorkflows

10

Everyone who works with coding agents seriously should build one from scratch, once. Not to ship it, but to understand what's actually going on. I built a skill that coaches you through implementing a ~300-line agentic loop yourself. No frameworks, no SDKs, just raw HTTP calls. The interesting part is that while you build your agent, the teaching agent is doing the exact things you're implementing. Context growing with each turn, tools consuming budget, shell access opening up your whole machine. You feel it because you're building it while experiencing it. It works in any coding agent that supports skills. I wrote about the thinking behind it and what you learn along the way. https://lnkd.in/de3wu5a9

42