Jacques Chester

Having terrific fun with migrating AI workloads from tightly coupled per-model calls to an agentic framework. I'm reworking the bookshelf demo from simple inference to use agentic frameworks to properly enrich the data, and thinking about wacking on a frontend to boot. I blame Damien Jones for their offhanded "you've got a series there" comment. Turns out I do! Expect new releases, blog posts and talks to follow.

4

2 Comments

I've been wrestling with how coding agents are breaking traditional documentation patterns. The "quick start" guide assumes human readers who can infer context and fill gaps, but agents need explicit, structured information. I keep finding myself dumping entire API references into prompts because agents can't distinguish between relevant and irrelevant sections. Worse, they're working with outdated training data or confidently generating non-existent methods. The typical workflow - one vague prompt followed by iterative refinement - produces brittle implementations that miss edge cases. This led me to experiment with building out SpecCraft (Thanks Claude 😃 ), which flips the process: comprehensive specification gathering before any code generation. It walks through a bunch of targeted questions across user workflows, data models, security constraints, and integration requirements. It then uses an MCP server to fetch documentation and opinionated guidance to generate projects and handle the knowledge transfer problem. The hypothesis is that documentation needs to be co-located with code and optimised for agent consumption, not human browsing. Instead of external wikis or scattered examples, agents get context-aware guidance that includes both the "what" and the "why" of architectural decisions. The real question is whether we're building tools for agents or teaching agents to use human tools better. Want to give it a go? Or just check it out - it is all on GitHub https://lnkd.in/gPgkwiS6 or just run: `npx @opensaas/speccraft init <project_directory>` What are your thoughts? How might we shape documentation and quick starts for a future where coding agents need the information and guidance?

11

2 Comments

Have you ever wondered how to decouple AWS stacks when using the CDK? If you have stack decencies this can be a little tricky to solve. New blog post published with the solution: https://lnkd.in/gEEr7eSN

7

🤔 I asked an AI to clean up my messy git branch and accidentally stumbled onto something bigger. What started as frustration with Zed's basic git integration led me to try something different: "Can you run an interactive rebase and group these commits by type?" It worked. At least it mostly worked. But more importantly, it was less irritating than doing it manually. No context switching, no remembering arcane git syntax, just describing what I wanted in plain English. This got me thinking about interface design patterns that keep repeating in software: → Git's powerful but terrible UX spawned GitHub (multi-billion company built on better interfaces) → SQL was designed in the 1970s to let "non-programmers interact with databases" → Both tried to solve the same problem: reducing painful context switches The fascinating part? SQL completely failed at its original goal. It became another specialized language that only programmers use. But it succeeded spectacularly as an abstraction layer. What if AI coding assistants are something like the next iteration of this 50-year pattern. Instead of learning new DSLs for every domain (git, SQL, YAML, etc.), we can just... ask for what we want. In English. I'm not saying SQL is 1970s prompt engineering, but I'm also not not saying that.... Full piece explores this pattern from 4GLs to modern AI tools, plus the tragic backstory of SQL's original design: https://lnkd.in/eeWqHzqX #AI #InterfaceDesign #SQL #Git #DeveloperTools

17

5 Comments

👀 Copilot SDK supports BYOK (bring your own key) scenarios. Here's my Copilot Bridge app with Qwen 3 via a local Ollama endpoint. Docs: https://lnkd.in/gUhSG78C

13

RAG Isn’t Broken. Your Engineering Is. My New Article is out: Most RAG systems don’t fail because of embeddings. They fail because the index is misconfigured, overloaded, or simply the wrong one. You can have perfect vectors and a powerful #LLM, but if #IVF / #HNSW / #Flat can’t surface the right context fast enough, the system will hallucinate, drift, or quietly return incomplete answers. In practice, the real engineering happens here: tuning nlist / nprobe instead of swapping models managing HNSW’s memory and recall gaps fixing chunking and context quality evaluating retrieval separately from generation #RAG isn’t a model problem. It’s a retrieval problem. If your system feels “off,” don’t upgrade your embeddings. Fix your index. #AI https://lnkd.in/e9n_DyPx

8

4 Comments

Trust is the most important for me. Sure, semantic versioning helps, and you can always roll back if needed, but when you're supporting close to 40k tenants, stability and reliability isn't optional. Open-source should make things easier, not harder. If trust is lost, people won't want to use the library anymore. Check out the latest episode of the Code. Deploy. Go Live. podcast to hear more perspectives on maintaining #PnPjs from Patrick Rodgers, Julie Turner and myself.

9

I'm back with another fantastic article on building.jane.app. Akshay Arora put together a great article outlining how our Backend Foundations team in the Infrastructure & Enablement group at Jane make Rails upgrades low friction for our developers, and seamless for our clinics. This article is the first part in a series where we share the framework we follow for keeping up on Rails releases at Jane App! https://lnkd.in/gTx_58Jw I'd love to hear how you keep on-top of major framework and library upgrades at scale, drop some knowledge in the comments 👇!

15

You'd be surprised how many doors you can open just by Asking. An art that has to be learned extremely well is "Asking". A quick summary of what I learned by listening to a Jim Rohn's seminar is, 1) Asking is the beginning of Receiving. So, start the process. 2) Receiving is not the problem. Failure to Ask is. 3) Receiving is like an ocean. There's plenty. The problem is that some people go to ocean with a tea spoon. Two ways to Ask are: 1) Ask with Intelligence (Define & Describe clearly) 2) Ask with Faith (Believe you can get what you want like a child. Not like an Adult.) On a side note, a powerful phrase to start-over something is, "I'm Sorry". This has the power to reflect, explore, open a new pathway and fix broken windows. This has the power to clear most misunderstandings or conflicts in any relationship or matter. However, ensure to back it up with "Accountability" and always "Act" upon it with execution. #maturity #leadership #askhelp #saysorry

2

1 Comment

If your application is managed through Git, your database should be too. That's why we're bringing GitOps to MongoDB with Harness DB DevOps. 👉 https://lnkd.in/gNwzEpwu

2

I've been thinking a lot about npm supply chain security lately and wrote up the publishing setup I'm pushing across the open source projects I maintain. For maintainers: use OIDC trusted publishing instead of storing long-lived tokens, gate automated releases behind GitHub Environments, enable package provenance, and keep your manual publisher list short. For consumers: switch to pnpm if you haven't already. Beyond being more reliable than npm, it has native `minimumReleaseAge` support (defaults to 1 day in v11) and a `trustPolicy: no-downgrade` setting that refuses to install a package version whose provenance level dropped compared to previous releases. No Renovate config needed. Both sides of this compound each other's efforts. 👉 https://lnkd.in/eC_6Dem2

6

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

Okay so why are we conflating abstraction with clean code? They're two different things and i have been seeing a lot of mix up post around it. Clean code = your code is readable, functional, makes sense to the next person. Abstraction = you're hiding complexity behind a well-defined boundary. One is a baseline. The other is a design decision. And abstraction doesn't belong to one phase — you might as well abstract during design, mid-feature, or in a refactor. It shows up when the problem tells you it's time. But chasing abstraction before your code even works or reads well? That's solving the wrong problem.

6

The Kroxylicious projects is excited (when are we not??) to announce v0.18.0. This release focused on supporting authentication both from the broker and in proxy! Release announcement: https://lnkd.in/gQ89SkUt release artifacts: GitHub: https://lnkd.in/gAaTgFKm Maven Central: https://lnkd.in/ghpcRGRV

23

Is it ok to treat Claude generated code as if it was generated by another team you relied upon? What if you trust it too much because it worked in the past but then it bites you some day in the future? https://lnkd.in/gY6DZPZi

8

Everybody is catching onto the research -> plan -> human review -> implement cycle as the most effective way to manage coding agent context. An important part of this is having the AI run its own QA on planning documents. A great workflow I've found is asking the AI to write all of its suggestions to a markdown file with prefilled defaults that you can overwrite: """ Review this document for issues & declare it fine or create an issue doc. Issue docs exist in the same folder as the original document and follow this template: # [issue] - [severity] [issue description] ## Option A - [title] [details] ## Option B - [title] [details] ## Option C - [title] [details] ## User Selection A (default) # [issue] - [severity] ... """ Override the defaults then follow up with prompt: "apply the user selections to the original document" Happy vibing! For more info on research -> plan -> implement see https://speckit.org/

11

So much of the advice and stories on here from "Distinguished Principal Super Mega Software Gods" are just so tepid. - We were building a docker image twice for two environments, so we used ~variables~ to reduce build time by 50%!! - When we traced our requests, we found that all of our API were twenty microservices called in single file. By flattening them, we reduced app load times by ✓✓✓6000%✓✓✓ - I used to not like AI, but then I vibe-coded a login prompt in A SINGLE DAY!!!1 Is it too much to ask for a post on how RDMA is used to connect logical partitions of custom-built truck-sized RISC-V neo-mainframes? Write about something cool.

22

9 Comments

I enjoyed this post from Andrew Lee about why building software takes longer than it seems it should. Worth a read, especially if you're a non-engineer working alongside engineers. https://lnkd.in/gsnphFzK

11

2 Comments

Staring at the screen this afternoon, waiting for my gitlab pipelines to turn green. My brain can't deal with the pause and it jumped back to a video I saw a few weeks back on General Agent's Ace. The video has been bugging me for a few weeks. Not necessarily a full-blown existential crisis, but it did raise the question; are we building our web portals completely wrong? If the next generation of AI tools can scrape screens and perform complex tasks across multiple products, websites, tools without a sweat, what does that mean for how we build them? The thought is very very tempting: could we not just sacrifice UX for raw speed? Do we even need quality interfaces? If AIs like ChatGpt and Gemini can understand our gibberish prompts, surely newer AIs can handle a clunky UI. But the idea falls apart the second the AI fails and a real, stressed-out human has to jump in to save the day. Preferably without being forced onto some hostile, machine-first interface. This leads to the real question; UI vs API. Or is that the wrong way to think? Instead of building separate machine-only APIs, what if we focused on making our UIs pleasant enough for humans, but boringly predictable for machines? Essentially, treating the UI as the API? Thinking like this would change a lot. Instead of the popular, but very “dry” OpenAPI specs; Could well-defined UX patterns become the next specification language, understood by humans and AIs alike? Perhaps. But it points to a more immediate reality: the concept of accessibility is getting a massive redefinition. For years, we've seen accessibility as a way to support human users with different needs. Now, AI agents are becoming a new class of "user" that relies on the exact same principles. A clean, semantic UI that’s clear to a screen reader is also perfectly clear to an AI agent. The business case for accessibility is suddenly no longer just about inclusion; it's about enabling automation. This feels like a shift. I'm curious to hear other perspectives. Are we about to see a renaissance for accessibility, driven by the needs of AI? What does "designing for everyone" mean when "everyone" now includes machines?

31

15 Comments