Vincent Batts

Spent part of this morning updating the eforge README. The two ideas it leads with now: stay close to the code without writing or reviewing it, and don't get locked in to a vendor. Staying close without writing reads like a contradiction - less so once the role shifts from writer to planner. Specs, architecture, module boundaries, acceptance criteria - that's the work now. eforge handles implementation, blind review, and validation in the background. The time goes into thinking about what gets built, not watching code get typed. Lock-in matters because the model landscape shifts constantly - quality, pricing, availability. eforge's backend is swappable between Claude Agent SDK or Pi (15+ providers including OpenAI, Google, Mistral, local models). The workflow survives whatever the next model / harness shakeup is. https://lnkd.in/gyp5n7rc #AgenticEngineering #SoftwareEngineering

2

Software teams are discovering something powerful: agentic automation that connects across the entire SDLC. In From the Bear Cave, Dan Faulkner and Vineeta Puranik break down how MCP enables connected workflows, what autonomy looks like in practice, and why trust and transparency matter. https://lnkd.in/ehkkueTc

38

I used to look at tools like Sora or Veo and think, "Okay, that’s impressive." But I never really saw a full feature film coming out of it. It felt… hollow. Then I saw a clip from Jon Finger today (link in comments) and it clicked. The video isn't pure AI generation. It’s a human performance, heavily styled and augmented by AI. The timing, the emotion, the intent, that’s all Jon. The AI just painted over the lines he drew. And honestly? It’s infinitely better than the "text-to-video" stuff flooding our feeds. This is exactly where software development is heading in 2026. We shouldn't be looking for tools that remove the developer. We need tools that keep the human as the orchestrator. Think of AI as the ultimate special effects budget for your engineering team. It doesn't replace the director or the actors. It just lets them build things that used to be impossible. If you’re building a dev team right now, stop trying to automate your people away. Find the tools that make them the center of the universe. Do you see AI as a replacement for tasks, or an amplifier for talent? I’d love to hear how your team is using it. #SoftwareEngineering #FutureOfWork #AI #HumanInTheLoop #DevTools

1

1 Comment

4 Common mistakes interviewees make in technical interviews that cost them an offer After conducting 100s of technical interviews, these are the things I found worth mentioning (and you should avoid during your next tech interview): 1. Not asking clarifying questions (if you don't scope out the problem, most likely you are solving the wrong problem) 2. Not thinking out loud (interviewer can't hear/see what you are thinking if you are not talking, try to share your logical thinking process) 3. Start coding without discussing the algorithms trade-off (you might spend precious interview time solving an O(n^2) algorithm where the interviewer is looking for a linear solution) 4. Do not test the code manually (Even the greatest programmer makes mistakes in their code, dry run your code with a simple yet effective test case) -- If you are preparing for technical interviews and/or need a mock interview, you can schedule it using the link - https://lnkd.in/gSbw2SM7

11

I had my first fighting moment with Claude last night... not because it did something bad not because it deleted anything but because it didn't follow our plan Creating the approach, the spec, is something we've been doing at Vivun for a while now. Its an amazing approach to SDLC, no lie - but does it work for underlying infra?? It should... I talk to an agent, we come up with a game plan, agent runs that game plan, EZ! But no... that's not what happened Plans never go as planned, so we had to fix as we went But then everything was ready..... I had a "test" controller.... Just need to copy it and use variables for the "real" controller We had a rock solid plan Claude decided to just override everything with values from the "real" controller leaving me in a state where I have 3 instances fighting for who the real swarm is.... Claude... WUT! I know the answer, context rot. All that "debugging" made things too difficult for the base agent to make sense of everything. The problem - me. I used the tool wrong. Keep your sessions clean "Reset" often The spec / plan is the guide, keep your agents anchored

3

2 Comments

Last night I was up late, working on agent permissions. The Claude tab was open. The problem, roughly. When you're running multiple agents across a stack, each one needs a scope. What it can read, what it can touch, what it can't. You also need to know, after the fact, what it actually did. Permissions and observability are the same question from two sides: what's allowed, what's auditable. Get either wrong and you've got an agent quietly modifying something three layers deeper than you intended, with no trace of why. To explain that to someone fresh, you need forty minutes and a whiteboard. To ask a real question about it, you need them to have already had the forty minutes. My peers at work have had the forty minutes. They're sharp. They were not, at that hour, six months into the specific shape of this problem on the specific stack I was working on. The conversation had a ceiling. A problem of geometry, not of friendship. A post came across my feed today that said it was cringe to hear someone say "I asked Chat what it thought." Then the post asked, do you not have friends? Peers? Coaches? There is a version of that complaint that's true. Using an LLM as social ammunition in a live human conversation is its own kind of tell. You can hear the speaker outsourcing something they should be holding themselves. The question as posed, though, assumes the alternative is always available. That somewhere in your life there is a peer who has been thinking about your exact problem, at your exact depth, ready at midnight without a forty-minute preamble. For most kinds of problems, sure, maybe. The further out you get on a specific edge, the smaller that set of peers becomes, until eventually it's empty, and you're standing in your office with a question that has nowhere to go. The Claude tab was what was in the room. It didn't need the whiteboard. The coach question is funnier. At a certain point in any specialty, you become the person other people ask. The coach hires a coach who hires a coach, and somewhere up the chain, there is no one. That's the shape of the frontier. The tool that helps now happens to be one people feel licensed to sneer at, which probably says more about the speed of the change than about the tool. I closed the tab and went to bed. The traceability problem was still there in the morning. So were the peers I like talking to, and the friends I have, none of whom had been holding this particular shape of context with me, which is fine, because it isn't their job. The room at the edge of the work is smaller than people realize. The thing that fits in it with you doesn't have to have a pulse. It just has to know what you mean. #DevLore #StackScrolls #AgenticEngineering #SoftwareEngineering If you've ever hit the ceiling of a conversation and realized the only thing keeping up wasn't a person, you're probably further into the frontier with me. Share with whoever's up late on something nobody around them is thinking about.

7

8 Comments

Documentation is no longer a knowledge base that developers consult. It's infrastructure that agents depend on. The technical writer who spent years thinking about how to structure information so a developer could find the right answer quickly? They're now the person who determines whether an agent acts on the right answer reliably. The audience changed. The stakes are higher. The craft is the same. Your docs aren't a deliverable anymore. They're a load-bearing wall. I write about what this shift means for technical writers and content strategists. With evidence, not anxiety. First essay coming soon. Subscribe here: https://lnkd.in/eJTZAR2S #TechnicalWriting #ContentStrategy #AIDocumentation

23

Although we run our core infrastructure at 2% of the price of the equivalent in cloud, this isn't a story about being frugal. It’s about firepower. For a deep-tech startup, compute is the absolute lifeblood of innovation. The goal isn't to save money on your cloud bill, but to get the maximum amount of compute for every dollar you spend. The cost delta = an innovation multiplier. Today, this is probably true for any startup.

15

1 Comment

There's a really high cost of duplicating code and we're all relearning that everyday with these coding agents. Until they get better at generating reusable code, bugs will run rampant. You can't "abstract it away" with more agents. You just get crappy software....

548

40 Comments

🚫 Slow teams? Rarely. ⚠️ Broken systems? Often. Too often, developers get blamed for “delays” when the real bottleneck lies in the process. 👉 Requirements shift mid-sprint 👉 “Done” is undefined 👉 Reviews drag for days 👉 Deployments feel like rolling dice This isn’t a speed problem—it’s a system problem. From my experience, sustainable speed emerges when we ensure: ✅ Clarity – in requirements and the definition of done ✅ Trust – empowering teams to own outcomes, not just tasks ✅ Resilience – with automation, observability, and iterative improvement When autonomy meets accountability, engineering organizations thrive. Not by pushing harder, but by scaling smarter. Fix the system—and speed will follow. Thanks Jordan Ambra for sparking this important conversation. #EngineeringLeadership #TechDebt #ScalingSystems #AutonomyAndAccountability

21

I've been experimenting with a "fan-out" architectural pattern for building multi-tasking agents. I'm using bedrock agentcore's serverless nature to handle concurrent requests in parallel. Inside each invocation, LangGraph acts as a router to run the correct specialized subgraph. This approach is showing a lot of promise, but I'd love to hear how others are tackling similar problems. What patterns are you finding effective for concurrent agent tasks? #AgentCore #LangGraph

13

Nearly 100% of the code in the new platform I'm working on is written by agents. Not a POC or experiment. We've been doing this for five months and are rolling to production now. Short version of what I've learned: TDD goes from nice-to-have to non-negotiable. Line-by-line review of 30k lines a day puts you back at human velocity, so you need quality defense in depth — pit robots against robots. And your new coding partner is neither your replacement nor a slop machine. Full post: https://lnkd.in/gKANJcMG

38

9 Comments

Common parlance amongst some today is "agentic code does not scale to human review. Humans write specifications, agents write implementations. Humans don't review the code". Do you know what a sev1 incident costs you? How about a sev2? Will your spec know all the multi tenant data invariants created over the years from migrations and backfills? Will it know the db indexes to optimize for, the locks, the race conditions? Where are the brittle parts of your system? Companies better start making a line item on that balance sheet for sev1 and sev2 incidents because they are going to explode if agentic coding takes off too early.

5

1 Comment

If you're a developer whose primary value has been writing code efficiently, it's time to honestly reassess where you stand. Doc Norton recently published something that frames this clearly. A post that I believe is spot on. He traces two previous sea changes in our profession, the PC and the web, and argues agentic coding is the third. But with a key difference: the previous transitions expanded the market for developers. This one might contract it. The PC shift took about a decade. The web took about five years. Norton thinks we have two to three years before agentic coding is the mainstream context for professional software development. I've spent 15 years advocating for BDD and practices that force clarity about what we're solving before we start building. For most of that time, implementation dominated the conversation. Because it was expensive and slow, writing code got all the status. That's changing fast. The developers who will thrive are the ones who were always focused on building the right thing, not just building the thing right. Problem definition. Outcome clarity. System-level judgment. Those skills have always mattered most. The market is just finally catching up. The good news: these are learnable skills. The uncomfortable news: the window for a comfortable transition is shrinking. Norton's observation from two previous shifts is that the people who came through well didn't wait for permission or a reskilling program. They started moving while it still felt optional. Make time for this one: https://lnkd.in/dZyYgpaV

50

7 Comments

A green CI checkmark does not mean a PR is safe to merge. Most of the PRs that cause real incidents in my job: * have tests * have reviews * have a clean pipeline ...And still shipped risk. The uncomfortable part of code review is rarely “Do we have tests?” It’s more often: * Are the right behaviors protected? * Did this change expand the blast radius? * Are we touching paths that look safe but aren’t exercised meaningfully? * Would I feel good owning this at 2am? Those instincts are hard to explain in a PR comment, especially when all the dashboards are green. That gap is what pushed me to start building a project that reasons about PR risk, not coverage percentage. Curious how others experience this: What’s the non-obvious thing that makes you pause before approving a PR? (Not looking for “needs more tests”, I mean the real signals.)

1

Generally a very good document to read and reflect on, but the advice to avoid mutation when appending to a list by taking a copy of the entire list with the appended item tacked onto the end made me wince somewhat (it’s a major Kotlin bugbear of mine - horribly and needlessly inefficient immutable collection types). If you want to do that sort of thing at least use persistent data structures. In languages not tooled for really pure FP - and sometimes even in Haskell if it’s just the clearest and most efficient path - I will often do tactical local mutation, while ensuring that the general data flow is immutable structures in and out of chained black boxes. Sometimes I’ll create a structure with the intention that the next thing along will destructively modify it (a dependency graph fed into a toposort, say), because there is no other client of the structure - it’s just a stage on the way to an outcome. In Typescript, of all languages, you’re really not supported if you want to use very pure FP idioms. Go (safely, judiciously) with the grain of the language! https://lnkd.in/eiAip8pn

4

2 Comments

During the "Ambient Agents" meetup last week, Brace Sproul gave us a walkthrough of Open SWE, a coding agent built on Langgraph. Open SWE monitors GitHub issues. When it gets a new one assigned, it kicks off a multi-agent architecture with a Manager, Planner, and Programmer. It can receive messages from users at any time during the process and incorporate them into the state. Check out the slides for diagrams explaining each agent: https://lnkd.in/g3PnNHqG And the code: https://lnkd.in/gY68TKYy I found the takeaways really interesting: * Summarization is hard: Especially with code changes that can get quite long, you literally can't send the entire context history to the LLM, and highly detailed old diffs may distract it. IIRC, the agent sends the last 20 messages, and summarizes the changes before. * Agentic > hard coded: Open SWE tends to use the agentic approach of "here are your tools, pick which one to use" for almost all tasks. Except for one.. * Explicit error handling: When an error happens, Open SWE stops everything and focuses on resolving the error. Otherwise, it could get too far afield and be unable to get back to a good place to solve the error. (Hopefully I didn't mis-represent anything I heard!) #Langchain #Langgraph

93

3 Comments

"Manual Testing is dead." I hear this at tech conferences all the time. It is usually the biggest lie in the room. There is a rush to automate everything. 100% coverage. CI/CD pipelines. AI-driven scripts. Don't get me wrong, at Testriq QA Lab, we love automation. It’s fantastic for regression and load testing. But automation has a fatal flaw: It only looks for what you tell it to look for. A script will tell you that the "Checkout" button works technically. But it won’t tell you that the button is covered by a pop-up ad on an iPhone 13 mini. It won’t tell you that the color scheme causes eye strain. It won’t feel "frustration." This is why we prioritize Exploratory Testing (https://lnkd.in/d4ePfpR3). Unlike scripted testing, Exploratory Testing is simultaneous learning, test design, and execution. It relies on human intuition, creativity, and the ability to "break" things in ways a developer never anticipated. Automation checks if the code works. Exploratory testing checks if the product works for the human. If you are launching a consumer-facing app (Gaming, eCommerce, Dating), you cannot rely solely on scripts. You need a human in the loop. My rule of thumb: 01: Automate the repetitive (Verification). 02: Explore the new and complex (Validation). Question for the Devs and PMs: What is the "weirdest" bug you’ve ever found that an automated script completely missed? #SoftwareTesting #ExploratoryTesting #QualityAssurance #UX #TestriqQALab #ManualTesting

10

3 Comments

Chunking and snippet extraction has been a huge focus lately - my latest blog dives into some of the work we've done on this to date, including support for a chunk rescorer in our semantic reranking retriever, as well as some useful ES|QL primitives to get more visibility into chunks and snippets. #elasticsearch #semanticreranking #snippets #chunks #chunking #esql https://lnkd.in/e6UD7iii

13