Ronaldo W.’s Post

I used to spend hours on Time series forecasting with modern ML approaches tasks. Then I tried vibe coding — letting AI handle the scaffolding while I focused on design. Result: 3x faster prototyping, same code quality. The workflow: 1. Describe the architecture in plain English 2. AI generates the boilerplate 3. I review, refactor, and optimize 4. Ship in days instead of weeks The developers who will thrive in the next 5 years aren't the ones who type the fastest. They're the ones who think the clearest. Have you tried AI-assisted development? What was your experience? #DataScience #DataEngineering #BigData

Most developers are using Claude wrong — and it's costing them time, money, and output quality. Here's what's actually happening under the hood, and how SubAgents in Claude Code change everything. Every AI model has a context window — a finite amount of text it can process at once. When you ask Claude to work on a complex codebase, it starts reading files, running tests, exploring dependencies... and all of that accumulates in one single window. Eventually, the AI starts losing earlier context. Quality drops. Costs spike. Speed slows. SubAgents solve this at the architecture level. Instead of one Claude doing everything sequentially, you have a main orchestrator Claude that breaks work into focused subtasks and delegates them to isolated SubAgents — each with its own fresh context window. Each SubAgent works independently, then returns only a clean summary back to the main thread. The result? ✅ Context stays clean : no token bloat in your main session ✅ Parallel execution : run security checks, code review, and test coverage simultaneously ✅ Specialist-level quality : each SubAgent is fine-tuned for its specific task ✅ Significant cost savings : lighter models handle focused tasks while the main agent handles complex reasoning Real-world example: reviewing a large codebase used to mean one Claude reading 40+ files sequentially. With SubAgents, you dispatch 4 agents in parallel — each reads 10 files — and the main Claude synthesizes their findings. What used to take 20 minutes now takes under 5. This is not just a feature. It's a new mental model for building with AI — thinking in orchestration, not just prompts. If you're building AI-powered development workflows, SubAgents are the unlock you've been waiting for. What's your current biggest bottleneck when working with AI on large codebases? Drop it in the comments 👇 Dario Digregorio Greg Brockman Andrej Karpathy Shreya Rajpal Logan Kilpatrick #ClaudeCode #AIEngineering #LLM #ArtificialIntelligence #DeveloperTools #AIAgents #Anthropic #SoftwareEngineering #FutureOfCoding #MachineLearning #AIProductivity #TechInnovation #SubAgents #ContextWindow #AIWorkflow

AI didn't replace my code review process. It made me a harder reviewer. Before, I'd catch the obvious stuff: naming, architecture violations, missing error handling, potential bugs. Now that AI generates a lot of the boilerplate, the easy catches are already gone before the PR is even opened. What's left is the stuff that actually matters: → Does this make sense for OUR architecture, not just any architecture? → Will this hold up at scale with real user data? → Is this the right abstraction, or just a clean-looking one? → What happens in 6 months when the team changes? AI-generated code is often syntactically perfect and conceptually shallow. It passes the "does it compile" test easily. It struggles with the "does it belong here" test. Code review used to be about catching mistakes. Now it's about catching decisions. How has AI changed the way you review code? #iOSDevelopment #Swift #CodeReview #AI #SoftwareEngineering #MobileEngineering

🚀 Just completed *Claude Code in Action* by Anthropic — and honestly, this confirmed something I’ve been thinking for a while: **AI won’t replace engineers, but engineers who don’t use AI will fall behind.** A few practical observations: • Claude Code isn’t just “smarter autocomplete” — it’s useful for structuring multi-step backend tasks • Plan Mode vs Thinking Mode maps surprisingly well to system design vs deep debugging • The real value shows up in **faster root-cause analysis**, not just code generation • When used right, this can significantly reduce turnaround time across services and teams The bigger takeaway: **AI tools like Claude should be treated as part of the engineering workflow — not as optional add-ons.** The teams that figure this out early will have a clear execution advantage. Curious how others are integrating AI into backend systems and architecture decisions. #ClaudeAI #TechLeadership #BackendEngineering #SoftwareArchitecture #AIEngineering #DeveloperProductivity

🚀 GIDS Day 3 — Rethinking How We Build AI Systems Over the past year, I’ve been working on multiple AI systems — from agent workflows and automation tools to full backend platforms like Orion. So going into GIDS, I wasn’t looking for “what is AI”. I was looking for: 👉 Are we building these systems the right way? 🧠 What became very clear Across sessions on agents, reasoning loops, memory, and distributed workflows: AI systems today are not about prompts. They are about architecture, orchestration, and reliability. ⚙️ 1. Agents are becoming backend systems Not scripts. Not wrappers. They are evolving into: • API-driven services • Tool orchestration layers • Stateful systems 🔁 2. Reasoning loops are the real core Shift from: Prompt → Response To: Plan → Act → Observe → Improve This is what actually improves: • accuracy • control • reliability ⚡ 3. Multi-agent systems = real scalability The moment you introduce: • event-driven flows • async execution • agent-to-agent communication You’re no longer building “AI features” — you’re building distributed systems. 🧠 4. Memory changes everything Without memory: chatbot With memory: system This impacts: • personalization • continuity • reasoning depth 🏗️ 5. From demo → production The strongest reinforcement: • Reliability > intelligence • Observability > prompt tricks • Engineering discipline > experimentation 🎯 What I’m taking forward These sessions didn’t introduce new buzzwords. They validated something important: 👉 Building AI systems is fundamentally a backend engineering problem with LLMs inside it And also highlighted areas I’m actively improving across my projects: • evaluation loops • failure handling • cost-aware design 🔥 Final Thought Most people leave thinking: “Agents are cool” But the real takeaway is: “Agents are just systems — the same engineering principles apply, just at a higher level of complexity.” Would love to connect with others building in this space 👇 #BackendEngineering #SystemDesign #AIEngineering #LLM #Agents #FastAPI #Python #BuildInPublic #GIDS #SoftwareEngineering

Is AI-generated code the fastest way to build features, or a ticking time bomb of technical debt? We're all marveling at the speed AI code assistants offer. They're fantastic for boilerplate and quick prototypes. But dive deeper, and a few uncomfortable truths emerge: * Hidden Complexity: AI can generate code that *works* but lacks elegance or maintainability. It often doesn't understand the larger architectural context. * Security Gaps: Auto-generated code might introduce vulnerabilities you wouldn't spot in hand-written, reviewed code. * Unfamiliar Patterns: Developers can end up maintaining code they didn't write, written in styles or using libraries they aren't fully comfortable with, slowing down future work. * "Black Box" Issues: Debugging or optimizing AI-generated code can feel like untangling a knot tied by someone else. The allure of speed is powerful, but we're not yet at a point where AI can reliably deliver production-ready, long-term sustainable code without significant human oversight and refactoring. The shortcut today is often the roadblock tomorrow. Follow for more raw takes on the evolving dev landscape. Save this if you're wrestling with these questions. Share with your team to spark the right conversations. #AIinDev #SoftwareEngineering #TechDebt #Coding

Most developers use Claude Code daily — but rarely think about what's happening under the hood. This is a solid system design breakdown of Claude Code as an AI coding agent: → How it perceives context (your codebase, terminal, files) → How it plans and executes multi-step tasks → The feedback loops that make it feel "intelligent" → Where it can fail — and why Worth a watch if you're working with AI tools or building agent systems. Link in comments👇 #AIEngineering #SystemDesign #ClaudeCode #SoftwareArchitecture #AIAgents

Automation without a human approval gate will eventually fire at the wrong time. When we built our content system, we trusted Manus to orchestrate the flow, Claude to reason through the copy, and Python to glue everything together. VS Code and GitHub kept the code clean and versioned. But early on, we skipped a simple human checkpoint before publishing. What we learned is that no matter how smart your AI agents are, automation that interacts with your audience needs a pause button. A human approval gate helps catch tone issues, timing mismatches, or subtle errors that AI alone can miss. This design lesson saved us from sending out messages that felt off or out of sync. It’s the control layer that protects your brand and builds trust. If you’re building AI systems that speak or act on your behalf, always build in a human review step before anything goes live. It’s a small effort that prevents costly mistakes and keeps your system aligned. How do you handle approval gates in your automation? Do you trust your AI to go solo, or is there always a human in the loop? #AI #SmallBusiness #Automation #AIInfrastructure #SystemsThinking

I’ve just published a new portfolio project: AI Workflow Observatory. It is a local-first observability dashboard for AI-assisted engineering workflows. The tool scans local Codex session logs and reconstructs the engineering process behind AI work: - context gathering - planning - implementation - verification - debugging / recovery - handoff quality - estimated cost in USD/EUR/PLN - workflow risk and verification quality The idea is simple: AI coding tools should not only produce code. Engineering teams also need visibility into how the work happened, whether it was verified, where the risk is, and how much iteration/cost was involved. This connects directly to the systems I’m interested in building: practical AI engineering, agent workflows, observability, evaluation, auditability, and operator-facing control layers. GitHub: https://lnkd.in/d8qPz5HB #AIEngineering #GenAI #LLMOps #AgenticAI #Python #FastAPI #Observability #RAG #AIAgents #PortfolioProject

🚀 Agentic AI Roadmap 2026 — From Experiments to Enterprise Systems AI is shifting from feature → autonomous execution layer ➡️ Prompting → Orchestration → Full-stack agent systems What matters now: 🧠 Foundations Python/JS, APIs, async, advanced prompting (context, reflection) 🔗 https://lnkd.in/gjg-32Qn 🔗 https://lnkd.in/gZvfU-cY 🤖 Agent Design Planning, decisioning, multi-agent systems (ReAct, AutoGen) 🔗 https://lnkd.in/gvgbGFUE 🔗 https://lnkd.in/gBUz5SU6 🔗 LLM Ecosystem Multi-model + function calling + structured outputs 🔗 https://lnkd.in/ghTxQ2AN 🛠️ Tooling (Execution Layer) APIs, retrieval, code execution + MCP standard 🔗 https://lnkd.in/gmUmDCJy 🧩 Frameworks LangChain, LangGraph, LlamaIndex 🔗 https://lnkd.in/g7qT7r3z ⚙️ Orchestration DAGs, event triggers, human-in-loop 🔗 https://n8n.io/ 🧠 Memory + RAG Vector DBs = context moat 🔗 https://lnkd.in/gZXAXu9P 🚀 Deployment FastAPI, Docker, Kubernetes 🔗 https://kubernetes.io/ 📊 Evaluation (critical gap) Tracing, feedback, auto-evals 🔗 https://lnkd.in/gZrT6c86 🔐 Governance Prompt injection, RBAC 🔗 https://lnkd.in/gcjpAU_d --- 🧭 Bottom line: > LLMs + Tools + Memory + Orchestration + Governance = AI Operating Layer #AgenticAI #AIEngineering #LLM #MLOps #AIArchitecture