Erich von Hauske Nakagawa

I love the idea of giving more autonomy and agency to our non-dev contributors. Product managers are already able to create prototypes with AI. Now, they can go one step further and actually contribute to the codebase. Chatting with GitHub Copilot directly from Teams, or opening a pull request from an issue with Copilot — this is just the beginning 🚀 This will clearly impact our development workflows: 🤏Shorter lead times for small and medium tasks 💨Faster path from idea to production 🚀Fewer handoffs and less friction Of course, developers may feel concerned — maintaining additional code written with AI, even after review, can be uncomfortable. But this is also a great opportunity: 👉 to better document developer expectations 👉 to formalize coding standards, architecture rules, and best practices 👉 so the AI can follow those guidelines and produce compliant, maintainable code Empowering PMs doesn’t mean replacing developers. It means raising the bar for collaboration between humans and AI — and between product and engineering. Curious to see how this evolves 👀

3

Have you ever heard of Claude Code SDK? It just got renamed to the Claude Agent SDK – because developers discovered it's not just for coding. **Here's what makes it powerful:** You get production-ready building blocks out of the box: • Automatic context management • Rich tool ecosystem (file ops, code execution, web search) • Fine-grained permissions and safety controls • MCP extensibility for custom integrations **The real game-changer?** You can build agents for virtually any workflow. Think beyond code: → SRE agents that diagnose production issues → Security bots that audit vulnerabilities → Finance agents that analyze portfolios → Research agents that synthesize massive document collections → Personal assistants that manage calendars and tasks The SDK gives Claude the same tools it uses in the terminal – but now you can programmatically integrate these capabilities into *your* solutions. Getting started is simple: ``` pip install claude-agent-sdk ``` A few lines of Python to spin up an agent that can read files, execute code, search the web, and coordinate complex multi-step tasks. It's the same infrastructure Anthropic uses internally. You're not building from scratch – you're leveraging battle-tested patterns with prompt caching, streaming support, and production optimizations. If you've been thinking about adding agentic capabilities to your product, this SDK makes it accessible. What agentic workflows would you automate first? ref.: https://lnkd.in/dAmztE4X

3

⚡ 𝐀𝐈 𝐰𝐨𝐧’𝐭 𝐰𝐚𝐢𝐭 — 𝐚𝐧𝐝 𝐧𝐞𝐢𝐭𝐡𝐞𝐫 𝐬𝐡𝐨𝐮𝐥𝐝 𝐲𝐨𝐮. The “colleagues” you didn’t hire are already working. I recently reviewed a pull request that solved a problem teams often wrestle with for weeks. The code was clean. The architecture was thoughtful. The rationale was better than most design docs. There was just one detail: 𝐧𝐨 𝐡𝐮𝐦𝐚𝐧 𝐰𝐫𝐨𝐭𝐞 𝐢𝐭. In my new article, I share what this shift means for engineering leaders, how AI moves from tool to coworker, why context becomes infrastructure, and what governance patterns make autonomy usable in production. 🔗 Read it here: https://lnkd.in/eMnarc2i #AgenticAI #AIAgents #ContextEngineering #AIGovernance #AIArchitecture #EnterpriseAI #SoftwareEngineering #EngineeringLeadership #LLMOps #ResponsibleAI #TechLeadership #AITransformation #FutureOfWork #VPInsights #TeamAmplification #AIStrategy #ProductionAI #Engineering #Developers #AI GEC NEWSWIRE

18

I’ve been writing a series of posts on the design principles behind Looping, a product I’m building to help teams run and evolve software over time. These principles shape the architecture underneath and have helped me prioritize clarity, composability, and long-term maintainability from the start. The latest post in the series is about Composable Services. In Looping, every service follows the same interface: it takes a hash of input and returns either Success() or Failure(). That consistency makes services easy to test, reuse, and chain together without resorting to sprawling conditionals or unpredictable side effects. The post walks through the structure, shows real examples, and touches on how it tracks source chains for observability and event logging. https://lnkd.in/ePkn-pF6 #ruby #rails #softwarearchitecture #buildinpublic

7

2 Comments

Pro Tip from the trenches of using Claude Code: Claude Code can spawn multiple agents to do the work, so you can work in true parallelism, without having to do everything serially. This has added benefit of not polluting the context on a per task basis. If you have multiple disconnected requests, spawn multiple agents. Batch process this by having it do research parallel and then ask you questions all at one time. Then kick off the agents. If done in a secure environment you can execute dangerously (more in an upcoming post), I've spent time upfront, and had operations run for over an hour in this fashion. Warning: More agents mean more token usage per minute. I also find that more than 4-5 agents Claude Code starts to chug in the terminal on my PC. As a manager this this feels like watching a whole project that would normally take weeks to execute, be completed in an hour. It's truly insane.

4

4 Comments

Just a little thought for Tech Tuesdays. Frameworks are supposed to speed you up, but the wrong choice can slow your team down. My encounter with frameworks stretches back at least two decades: early frameworks focused on abstracting the MVC design pattern, but modern frameworks have become very complex, bundling dependency injection, middleware, security layers, caching, ORMs, and more into a single, tightly coupled structure. While powerful, many modern frameworks tend to do too many things all at once. In doing so, they introduce a form of technological risk by imposing constraints and complexity that may not be necessary for the problem at hand. Similar risks exist when choosing a programming language, an operating system, or even hardware. The real question, therefore, is when their use is justified. This principle extends beyond software. The way we work day to day is also governed by frameworks in the form of processes and operating models. Too many processes can make an organization rigid, burdened by unnecessary constraints that slow execution. Too few, and a growing business struggles to maintain alignment, consistency, and control. Choosing the right framework begins with a deep understanding of your objectives. Many teams adopt frameworks because they are popular or fashionable. A disciplined architect, however, starts with the simplest framework that meets the current need and introduces additional complexity only when it is truly required. The ability to defer an engineering decision is often the best decision.

4

Some themes I'm hearing from people having success AI coding agents are explicit context, documentation through time, and automated feedback mechanisms. Explicit context includes the practices and assumptions that had previously been shared via IC senior/junior mentorships. Explicitly articulating architectural patterns, constraints, domain boundaries, language-specific design patterns, the definition of done, refactoring signals, error handling policies, optimization opportunities, etc. What would have been incrementally, lazily, and only verbally surfaced during an apprenticeship relationship is promoted to one or more documents. Documentation over time is the history behind why code works a certain way: special cases, environment-specific behaviors, why some IPC was chosen over another. While this information is often available in commit history or cryptic comments, it's less often made first class. Artifacts like ADRs capture the evolution of code. This historical documentation provides counterbalancing evidence against what is intentionally absent from the current codebase version. Automated feedback mechanisms include style, code organization, linters, compiler warnings as errors, semgrep policies, OWASP Web Testing Guidance, fitness functions for correctness, unit tests, fuzzers, and similar types of functional and non-functional feedback mechanisms. These are guardrails that operate at agent speed and provide actionable corrective signals to ensure alignment These are also hallmarks of pre-AI high-performing engineering teams. They highlight the importance of shared understanding, history, and actionable feedback. In my experience these practices help most teams to be more effective, independent of how they are constituted. 

17

5 Comments