Adam Tornhill’s Post

AI is not just for ‘new stuff’ - this is a great example of how it has totally changed the discourse around modernising old code / applications. I saw this myself picking up a (complex) 10 year old native iOS project and seeing it brought back to life, a project so hideously messy, doing it the old style just wouldn’t have worked. Now it can be done.

The kind of research and experiments done by the CodeScene team is brilliant. This is the latest example and well worth the read. I've been playing with smaller versions of this not only using codescene and it is clearly promising, so while not surprised, it's super interesting to see it at bigger scale

In my experience all those tiny tidy up refactorings might make code more readable to a human but won’t improve quality much, as quality is not about duplication and loc per function but rather about design ideas. Alan Kay said, perspective worth 80 IQ. That’s what actually makes code easier to understand. The cognitive aspects, not just the structural organization.

Three weeks, four thousand dollars in tokens, 300K lines to perfect Code Health. The number is the headline; the loop is the bit worth stealing. The agents did not refactor 300K lines in one go, they refactored a few, got scored, and wrote down what worked. That playbook is the real output. A quality gauge sitting outside the model is the only reason "perfect" means something here rather than whatever the agent felt like calling it. Also, refactoring Street Fighter III is the first AI use case I have been genuinely jealous of.

**Your AI code agent probably lies to you. Here's how to fix that.** Most coding agents hallucinate. They generate plausible code that looks right but fails at runtime—or worse, silently breaks your logic. For founders racing to validate an idea, these hallucinations are expensive. Sonde, a new open-source project, takes a harder line: it refuses to guess. Instead of letting the AI infer relationships in your codebase, Sonde builds a local code graph—a deterministic map of functions, classes, and dependencies. When an agent asks a question, Sonde answers from verified facts or says it doesn't know. **Why this matters for MVPs** Speed without accuracy is just waste. A buggy prototype won't convince investors or users. You need code that works, or at least fails loudly so you can fix it fast. Deterministic tooling—tools that produce the same output given the same input—gives you predictability. When your AI agent grounds itself in a local graph that won't hallucinate, you catch mistakes before they reach production. You spend less time debugging phantom bugs and more time validating your market. **Determinism + privacy** A local graph runs on your machine. Your proprietary logic stays private. The graph updates as you write, so the agent always has current information. For developer tools or any product involving code generation, this level of reliability is table stakes. **How TechAhir builds working, sellable products in days** We don't rely on vibe-coding or hope the AI guesses right. Every project at TechAhir is led by a senior developer who acts as the human guardrail. When we use AI to accelerate scaffolding or boilerplate, it's constrained by the same kind of deterministic checks that tools like Sonde provide. Our customized-model QA catches edge cases and integration issues that generic code generators miss. We test against real use cases, not invented scenarios. The result: virtually zero defects and an MVP you can demo to investors or ship to early users on day four. Speed WITH discipline. That's how you go from idea to traction without burning weeks on rewrites. **The takeaway** Investors and engineering teams are tired of "fast but flaky" tools. If your MVP involves code generation or agent-driven development, show that you catch mistakes or refuse to guess. A working demo that fails gracefully beats a clever prototype that breaks silently. Sonde's approach—open-sourcing early, prioritizing reliability over cleverness—is a model worth following. Whether you're building developer tools or validating any technical idea, determinism is your differentiator. [Get your MVP built in 3 days](https://lnkd.in/eqU3wDDH) #AIAgents #DeveloperTools #MVPDevelopment #CodeGeneration #TechStartups

**Your AI code agent probably lies to you. Here's how to fix that.** Most coding agents hallucinate. They generate plausible code that looks right but fails at runtime—or worse, silently breaks your logic. For founders racing to validate an idea, these hallucinations are expensive. Sonde, a new open-source project, takes a harder line: it refuses to guess. Instead of letting the AI infer relationships in your codebase, Sonde builds a local code graph—a deterministic map of functions, classes, and dependencies. When an agent asks a question, Sonde answers from verified facts or says it doesn't know. **Why this matters for MVPs** Speed without accuracy is just waste. A buggy prototype won't convince investors or users. You need code that works, or at least fails loudly so you can fix it fast. Deterministic tooling—tools that produce the same output given the same input—gives you predictability. When your AI agent grounds itself in a local graph that won't hallucinate, you catch mistakes before they reach production. You spend less time debugging phantom bugs and more time validating your market. **Determinism + privacy** A local graph runs on your machine. Your proprietary logic stays private. The graph updates as you write, so the agent always has current information. For developer tools or any product involving code generation, this level of reliability is table stakes. **How TechAhir builds working, sellable products in days** We don't rely on vibe-coding or hope the AI guesses right. Every project at TechAhir is led by a senior developer who acts as the human guardrail. When we use AI to accelerate scaffolding or boilerplate, it's constrained by the same kind of deterministic checks that tools like Sonde provide. Our customized-model QA catches edge cases and integration issues that generic code generators miss. We test against real use cases, not invented scenarios. The result: virtually zero defects and an MVP you can demo to investors or ship to early users on day four. Speed WITH discipline. That's how you go from idea to traction without burning weeks on rewrites. **The takeaway** Investors and engineering teams are tired of "fast but flaky" tools. If your MVP involves code generation or agent-driven development, show that you catch mistakes or refuse to guess. A working demo that fails gracefully beats a clever prototype that breaks silently. Sonde's approach—open-sourcing early, prioritizing reliability over cleverness—is a model worth following. Whether you're building developer tools or validating any technical idea, determinism is your differentiator. [Get your MVP built in 3 days](https://lnkd.in/eqU3wDDH) #AIAgents #DeveloperTools #MVPDevelopment #CodeGeneration #TechStartups

"The AI kept trying to make the code work. Sometimes the right thing to do is fail." That line came out of one of our engineers on a real project. It is probably the most honest thing we have said about vibe coding. The term started as a joke. Andrej Karpathy coined it to describe a casual way of building with AI, where you describe what you want, accept what comes out, and do not look too closely at what is underneath. It was never meant to describe serious engineering. But it caught on and became a catch-all for any workflow where AI writes a significant portion of the code. That is where things get blurry. Our team draws a clear line. Using AI in development means the engineer is still directing the work, reviewing the output and making deliberate decisions about what stays. Vibe coding in the original sense means prompting and shipping without fully interrogating what was written. The first is a productivity tool. The second carries risks that only show up when something goes wrong in production. We do the first. The speed gains are real. But the engineer's judgment never leaves the room. The clearest example came on a client project with a complex integration layer. What used to require entering the same data repeatedly across multiple systems was rebuilt using AI in a fraction of the usual time. Then one data source started sending back incomplete responses. The AI kept the flow running, added backup values, and quietly handled the error. The system looked fine. What it had built was an output based on guessed data rather than real data. An answer that looks right but is not is worse than no answer at all. The AI was not wrong. It kept the code running, which is what it is built for. What it could not know was the business context. That judgment has to come from the engineer behind it. We changed our approach after that. Rules go in before the AI starts writing. What to follow, what to avoid, what should happen when something breaks. In many situations, failing clearly is the right behaviour. A visible failure shows you what went wrong. A hidden one becomes a much bigger problem later. For repetitive code, integrations, internal tools and first drafts, we let AI do the heavy lifting. For business logic, error handling, and anything where the stakes are high, we work through it carefully ourselves. Not because the AI cannot write it, but because in those areas almost right is not close enough. Vibe coding as a trend is real. But the way the term is used now covers everything from casual prototyping to serious production work. Knowing which mode you are in is what makes the output reliable. What has your experience been with it? Ashutosh Waman [ arieotech IT company, Vibe coding, Vibe Coding is Hype or Real, AI Vs Vibe Coding, tech company, coding]

Interesting blog post on AI Code review by linkedin. To produce reviews developers would actually trust, LinkedIn had to build an entire engineering system around the models: • Multiple independent reviewers with complementary strengths • Repository, use-case, and organization-specific rules • Cross-validation and deduplication of findings • Pre-release evaluations for every model or prompt change • Gradual rollouts, observability, failover, and operational SLAs • A feedback loop measuring whether suggestions appeared in the final merged code

I’ve been thinking a lot about how code review needs to evolve in a world where producing code has become much cheaper. LLMs can already generate features, tests, migrations, integrations, and refactorings at a speed that human review simply cannot match. But perhaps the answer is not to read more code, faster. In the article below, I propose a different approach: signal-oriented code review. The idea is to treat the diff not as a uniform sequence of lines that deserve the same level of attention, but as a source of signals about the change’s intent, risk, structure, verifiability, and longevity. These signals are not automated quality scores, and they do not replace the reviewer. They help indicate where deeper investigation is worthwhile. signal → evidence → file → method → line of code AI helps us see. Human judgment remains essential. This is a thesis I’ve been exploring in practice, and I plan to develop it further through a series of articles focused on different engineering signals. The Future of Code Review: Signal-Oriented Review https://lnkd.in/dVsUErxw #SoftwareEngineering #CodeReview #AI #SoftwareArchitecture #Engineering

The debate around skipping the review of AI-generated code misses the most critical point: Accountability. When a team is truly accountable for a system's end-to-end outcome, code reviews are non-negotiable. A PR approval is an explicit commitment to shared ownership, right? If my team writes a PR, and I put a thumbs-up to it, I'm accountable if production breaks. It's called shared ownership. If the code is written entirely by AI, 80% by AI, 50% by AI, why should it make a difference?! We still care about having good outcomes 🤔 It is true that coding assistants are changing the shape, size, speed, and complexity of PR; I am not denying that. We definitely have to adapt to the moving reality, but it has to stay within the motto of ownership. Over the last 1–2 years, my team has continuously evolved our PR workflows to make sure that speed and rigor aren't exclusive. One of our goals was to structure PRs so that reviewers can read code following the pyramid principle: starting with clear mental context before touching a single line of logic. Here are the simple changes we made to make this scalable: - Review agents and linters catch bugs, formatting, and edge cases upfront. PR authors are accountable for resolving these sequentially before calling for human approval. - Every file contains an updated and concise header summarizing its core logic and intended behavior, giving readers immediate context before jumping into code. - Any architectural shift or dependency change must be explicitly mapped out and justified alongside agentic output verification. - Shared team AI instructions for testing, linting, coding guidelines/conventions, and dependency management ensure consistency across the entire codebase. At the end, we normalized our coding practices in agreement (and it's better enforced by agents, frankly 😅 ); we're able to speed up execution while ensuring the team increases its code knowledge. So yes, reading code is changing, but please, for the sake of product quality, let's not stop reading what's being shipped to prod.