GitHub Agents Limitations: Vibe Coding vs Engineering Reality

Vibe coding just broke my codebase. Not because the model can't write Python, because it forgot the architecture existed halfway through the refactor. Last year, “vibe coding” was enough. This year, my projects started breaking for a different reason. Not because the model couldn’t write code. Because it couldn’t hold the whole system in its head long enough to finish the job. That’s why Z.ai’s GLM-5 announcement caught my attention. Not the hype. The engineering choices. GLM-5 scales from 355B to 744B parameters. But the more interesting number is this: 40B active parameters. That’s a very specific bet on “big brain, sane runtime.” Then they go a level deeper. They add DeepSeek Sparse Attention to keep long context without turning inference into a bonfire. And they admit the part everyone feels but few say out loud: RL is where competence becomes excellence… …except RL at LLM scale is painfully inefficient. So they built “slime,” an async RL setup to iterate faster. Lesson for builders: We’re moving from “prompting output” to “operating systems.” If your model can’t plan, remember, and recover… You don’t have an agent. You have autocomplete with ambition. What convinced me this wasn’t just branding? They’re showing “long-horizon” results that look like real work. Vending Bench 2 (1-year simulated business): GLM-5 ends at $4,432. That’s not a cute demo. That’s budgeting, inventory, compounding decisions, and not self-sabotaging over time. On SWE-bench Verified: 77.8. Not #1 overall, but firmly in the tier where “ship this” starts becoming realistic. Then they make the product move I’ve been waiting for: Document-native output. Not “here’s text, go format it.” Direct .docx / .pdf / .xlsx deliverables. That’s how you turn models into something teams can trust. Actionable advice (how I’m adapting my workflow this quarter): • I’m splitting work into 2 loops Loop 1: Plan + constraints Loop 2: Execute + verification • I’m treating context like a budget If the agent can’t manage it, I add explicit state Decisions, assumptions, open questions, next steps • I’m benchmarking agents on “finish rate,” not “first draft quality” Did it ship a usable artifact Did it survive edge cases Did it keep the system consistent • I’m prioritizing open weights with permissive licensing for internal tools GLM-5 shipping under MIT is a signal It changes what you can safely build If you’re building agents, this is the shift: Chat is cheap. Completion is expensive. And the winners will be the teams that engineer for completion. What’s the biggest thing your current “agent” still can’t reliably finish end-to-end? ♻️ Repost to update your network on the Agentic future. + Follow me for more updates on AI Agents and Automation. Link in the first comment ⬇️ #AI #Agents #LLM #OpenSource #DeveloperTools #Productivity #SoftwareEngineerin

I’ve been thinking a lot about how structure and syntax quietly shape engineering decisions long before any “architecture diagram” is drawn. When a codebase grows, things like: - where blocks open and close, - how scopes are expressed, - whether structure is explicit ({}) or implicit (indentation), - how much the language enforces vs. suggests, start influencing more than aesthetics they influence how teams reason about systems. In large React apps I’ve worked on, brace discipline determined whether components felt like independent units or tangled scripts. In Python services, indentation-as-structure pushed me to design smaller functions because the language makes nesting “feel expensive.” In TypeScript, explicit boundaries encouraged clearer ownership between domain logic and UI concerns. These details compound: • onboarding speed • review quality • bug surface area • how confidently you can refactor after 6 months I’ve come to see syntax not as a preference war but as a cognitive contract between developers and the future maintainers of their code. Lately I’ve been revisiting: how different brace/indent styles affect diff readability, how AST-driven tools interpret structure vs. how humans do, and how conventions in one language leak into another when teams go polyglot. Curious how others think about this , Have you seen syntax choices materially change the trajectory of a project? #SoftwareEngineering #CodeQuality #SystemDesign #TypeScript #Python #FrontendEngineering #CleanCode #DeveloperExperience

Understanding JavaScript's array methods—map, filter, and reduce—is essential for writing efficient, readable code. These methods not only simplify data manipulation but also promote immutability and functional programming principles. In our latest blog post, we break down each method with practical examples to help you transform, filter, and aggregate data seamlessly in your projects. Whether you're a junior developer or looking to sharpen your skills, mastering these array methods can accelerate your development process and improve code quality. Let's discuss: how have you used map, filter, or reduce to solve a tricky problem in your code? #javascript #webdevelopment #programming #coding #developers Check out the actual blog here : https://lnkd.in/g_hwWRyX Note: This post was generated through an AI workflow. If you notice any issues, please contact me.

Ever feel like your team’s code is a bit of a tangled mess? That was us, not too long ago. Production issues were popping up more often than we liked, and figuring out what went wrong felt like an archaeological dig. It was slowing everything down, honestly. We knew we needed a change, but where to start? My focus shifted towards instilling more disciplined coding practices. It wasn't about pointing fingers, but about building better habits together. We started talking about object-oriented principles and standard design patterns, really digging into how we structured things. I tried to lead by example, sharing insights and offering guidance on our PHP and Python/Django services. It was a lot of back and forth, explaining the ‘why’ behind each suggestion. And you know what? It’s made a noticeable difference. The number of unexpected bugs has gone down. Things are just… more manageable now. It feels good to know the codebase is more robust and that we’re all better equipped to tackle those tricky incidents. It’s a relief, frankly. What have you found most effective in improving code quality within your teams? Would love to hear your thoughts. #SoftwareDevelopment #EngineeringCulture #TechLeadership #CodingPractices #Teamwork

What is the actual "First Rule of Programming"? 🤔 If you ask 10 different developers, you will probably get 10 different answers. While there isn't an official constitution for us coders, here are the 4 unofficial rules we all live by: 1️⃣ The Rule of Survival 🧟♂️ 👉 "If it works, don't touch it." The ultimate mantra for legacy code. If you stumble upon a bizarre block of code that defies all logic but somehow keeps the entire app running... step away slowly. Fixing what isn't broken usually introduces 3 new bugs. 2️⃣ The Rule of Optimization 🏎️ 👉 "Don't do it." (Coined by Michael A. Jackson). Rule 1: Don't do it. Rule 2 (For experts only): Don't do it yet. Premature optimization is the root of all evil. Write clean, readable, and working code first. 3️⃣ The Practical Rule 🧠 👉 "Understand the problem before writing a single line of code." Jumping straight into your IDE without mapping out the logic usually leads to writing 500 lines of code you'll just have to delete later. Think first, type second. 4️⃣ The Modern-Day Reality 🤖 👉 "Google the error message (Or ask AI)." No engineer memorizes everything. The true skill in 2026 isn't knowing all the syntax by heart; it's knowing how to effectively search for the solution. Which one of these is your personal "First Rule"? Or do you have a different one? Let me know below! 👇 #SoftwareEngineering #DeveloperLife #Coding #TechCareers #WebDevelopment #ProgrammingHumor

Just published: my retrospective on shipping a production C/C++/C#/Python numerical library in 2 days instead of the estimated 3 weeks using spec-driven development. The twist? It was my first project with C# and pybind11. I wrote neither by hand. We used to program in assembly, then C, then Python. Now we're programming in Markdown. Key takeaways from the article: - Spec-driven development treats specifications as executable documents — detailed enough that an AI agent can implement directly from them - The workflow has two phases: iterative planning (producing a spec) and agent-driven implementation — with explicit feedback loops between them - When you think you're done planning, you're not. A fresh-session cross-check catches inconsistencies both you and the AI will miss - Speed without review produces technical debt at 10× the normal rate. Active review is non-negotiable - AI agents start fresh every session. Engineers who can navigate ambiguity and write clear specs become force multipliers; those waiting for well-scoped tickets may find themselves competing with agents The productivity gain is real but nuanced: you're 10× faster at writing code, while spending more time on what actually matters — planning, reviewing, and making judgment calls. Would love to hear your experiences! #SpecDrivenDevelopment #AIinSoftware #GitHubCopilot #SoftwareEngineering #AgenticAI #DevOps

Literally the reason I created PMAT, which I believe is the best tooling for coding with agents, i.e. super lint. You need signals, not reading code, like a sensor vs a backup camera in a car: https://lnkd.in/eSEnCYWT

Build Log: The Moment I Switched to Claude Code (And My Entire Debugging Workflow Changed) I've been building Chikoh — an AI-powered fantasy sports and prediction platform — nights and weekends while working my day job. Every hour counts. Every tool decision matters. For months I was using Cursor and Warp with various LLMs behind them. Both connected to my repo. Both competent. Both fine. Then I switched to Claude Code with Opus 4.6. And "fine" stopped being acceptable. Here's what changed: -- The Context Gap Cursor and Warp could see my code. Claude Code seems to understands it. That sounds like marketing copy but I mean it literally. When I'd hit a bug in Cursor, I'd get a fix for that file. When I hit the same kind of bug in Claude Code, it traces the issue across files, catches the downstream effects, and patches the actual root cause — not just the symptom. It's the difference between a contractor who reads blueprints and an architect who knows why the building was designed that way. The Debugging Shift I used to spend my limited evening hours hunting bugs. Now I describe the behavior I'm seeing and Claude Code finds issues I didn't even know existed yet (or I just ask for an audit and it finds things that are wrong I haven't discovered yet). It connects patterns across my codebase — migrations, middleware, API endpoints — in ways that feel less like autocomplete and more like pair programming with someone who's actually read the whole repo. Last week it caught a cascading issue across my database layer, middleware, and frontend that would have taken me hours to trace manually. It found it in one pass. The Builder's Take I'm not an engineer by trade. I'm a product manager with 24 years in payments who's building this thing because I see the gap in the market (and I wanted to learn and have fun building something that's hopefully useful). That means my tolerance for tool friction is zero. I don't have time to babysit my AI assistant. What I've learned: not all AI coding tools are equal, and the differentiator isn't the model — it's how the tool uses context. Cursor and Warp are good products. But Claude Code operating on the full repo with Opus 4.6 behind it is a different category. For anyone building a side project with limited hours: your AI tooling choice is a force multiplier. Choose wrong and you're debugging your debugger. Choose right and you're shipping. Chikoh is shipping (getting it done in time for Fantasy Baseball season)! #BuildInPublic #ClaudeCode #AI #FantasySports #SideProject #DevTools #BuildLog

Beyond the Hype: Examining the Code Quality of Emergent.sh 🛠️ There’s a lot of talk about "Vibe-Coding," but as a builder, I care about the output. I used Emergent to generate SocialProof Pilot last night, and I was genuinely surprised by the stack: The Backend: Clean Python code. Logical, PEP 8 compliant, and scalable. The Frontend: React. Proper component separation and state management. The "Agentic" workflow didn't just write code; it architected a solution. It handled the "glue" between the frontend and backend that usually takes hours to debug. I’ve attached a 4-page deep dive into the SocialProof Pilot architecture and why this stack (Python + React) is the future of rapid deployment. What do you think? Is AI-generated code ready for production? ⬇️ #SoftwareEngineering #AI #Emergent #SocialProofPilot #WebDev

I’ve learned one brutal truth. Coding is fun. Debugging is the real job. 😂 When I started my career, I thought developers spend time: Building features Creating beautiful UIs Writing clean React code Reality? 70% debugging 20% Googling 10% “who wrote this code?” (sometimes me from last week) Anyone can write code when everything works. But real developers are made when: The API breaks State behaves weirdly CSS works on Chrome but not Safari Production crashes 5 minutes before demo That’s where the game starts. In the AI era, this is even more interesting. AI can generate code in seconds. Copilot can autocomplete functions. But when the bug says: “undefined is not a function at 2:13 AM” AI sleeps. You don’t. 🙂 Debugging teaches you things no tutorial can: How to think calmly How to break problems into pieces How to read messy legacy code How to find root cause (not just patch fixes) Honestly, debugging is like detective work. Less “developer” More “software Sherlock Holmes” 🕵️♂️ After 4+ years, I can confidently say: Great engineers aren’t great coders. They’re great problem solvers. So if you want to grow faster: Don’t just learn new frameworks. Learn how things break. Because tools change every year. Debugging skills stay forever. #FrontendDevelopment #Debugging #ReactJS #JavaScript #SoftwareEngineering #ProblemSolving #AI #WebDevelopment #Developers #TechLife #CareerGrowth #LearningInPublic #Engineering