Ben Force

One of the more controversial things I teach to developers becoming architects is that code quality isn’t as important as architectural quality. In the right architecture, poor code will not bring the system down. In a poor architecture, great code won’t tip the scales. If the industry now insists on poor code at huge volumes, then architecture becomes essential. Because everything is becoming automated and happening at speed, this means old school ”rules of thumb”, artisanal, gut feeling architecture simply won’t scale. We need a scientific approach to architecture. I think the current LLM rush is based on fool’s gold, but if you’re going to insist on doing it because everyone else is, then a scientific approach to architecture is absolutely necessary. https://lnkd.in/dPV4db3A

169

11 Comments

Another day, another engineer asking: “SSM or Secrets Manager?” So, I finally wrote it down. Whenever I review a low-level design from one of my engineers and a secret is required—an API key, database credential, or any sensitive value—someone inevitably asks: Should we use AWS Secrets Manager or SSM Parameter Store (SecureString)? The answer isn’t always straightforward. In this blog post (the link is in the comments section), I break down the key differences, pros and cons, and share my real-world recommendations on when to use each. #aws #cloudsecurity #secretsmanager #ssm #devops #serverless #platformengineering #awstips

128

12 Comments

Here's an uncomfortable truth: many developers struggle to produce effective documentation. I was one of them. My commit messages looked like "fixed bug" and my PR descriptions were basically empty. Then I discovered QuillBot's Chrome Extension and it completely changed how I communicate as a developer. It's not just another grammar tool. It's a structured, lightweight solution tailored for developers who need to write clear documentation, PRs, and emails while juggling complex codebases. Here's what QuillBot handles for me daily: ✔️ Paraphrasing technical explanations - Turn complex logic into clear comments ✔️ Grammar checking commit messages - Professional git history that impresses leads ✔️ Humanizing AI-generated documentation - Make ChatGPT docs sound naturally written ✔️ Polishing PR descriptions - Clear, concise explanations that get faster approvals ✔️ Improving client emails - Professional communication without grammar anxiety Whether you're writing technical blogs, documenting APIs, or just want to sound more professional in team communications, QuillBot helps you stay consistent without the writing overwhelm. The best part? It works right in your browser. No switching contexts, no breaking flow - just better writing wherever you type. As developers, we spend 40% of our time communicating. Why not make it effortless? Try QuillBot’s Chrome Extension for free - your future self (and your code reviewers) will thank you. What's your biggest technical writing challenge? #QuillBotForWork #QuillBotPartner #Ad

163

20 Comments

Your coding skills are worthless if no one understands what you're saying. Here's how to transform from a technical expert to a strategic powerhouse: 1/ Decode Business Objectives ↳ Understand what truly matters to leadership ↳ Connect your data directly to company goals 2/ Speak Their Language ↳ Translate complex algorithms into dollar signs ↳ Show impact, not just technical complexity 3/ Master Data Storytelling ↳ Create narratives, not just spreadsheets ↳ Make your insights compelling and memorable 4/ Deliver Actionable Insights ↳ Every chart should trigger a decision ↳ Recommend clear, executable strategies 5/ Build Contextual Intelligence ↳ Look beyond numbers ↳ Understand the broader business ecosystem 6/ Simplify Technical Complexity ↳ Explain like you're talking to a curious 5-year-old ↳ Cut the jargon, focus on clarity 7/ Learn Business Dynamics ↳ Study industry trends ↳ Know what keeps executives up at night 8/ Network Strategically ↳ Build relationships across departments ↳ Be more than just the "tech person" 9/ Continuous Learning ↳ Stay curious about business strategy ↳ Read beyond technical journals 10/ Quantify Your Value ↳ Track how insights drive decisions ↳ Prove your worth beyond code Technical skills get you hired. Strategic communication gets you promoted. Combine analytical depth with business acumen, and you become unstoppable. ♻️ Repost to help data professionals unlock their true potential. Follow Tuan Sihan for frameworks that turn data nerds into business heroes.

98

31 Comments

If you can’t tab through your product, it’s not accessible. It’s not finished. It’s not “MVP.” It’s a lawsuit waiting to happen. Here’s what most dev teams get wrong: They build with <div>s, <span>s, and CSS. Then they hope screen readers and keyboard users will “figure it out.” Spoiler: they won’t. And they shouldn’t have to. The bar isn’t high, just do this: Use the platform • Use <button>, not a styled <div> • Use <label for="id">, not placeholders • Use <fieldset>, <legend>, <nav>, <main>, <section>, <header>, etc. Fix your tab order • The DOM defines tab order. Visually reordering with CSS is fine but never reorder focus invisibly. • Use tabindex="0" to add focus. • Use tabindex="-1" to manage focus programmatically (e.g. bring focus to a modal). Respect focus • Every interactive element needs a visible focus state (not outline: none) • Modals must trap focus inside • Focus must return where it came from when closed Support real keyboard interaction • Buttons: Enter / Space • Dropdowns: Arrow keys + Enter • Escape: should exit modals, menus, popovers • Don’t invent new interaction models unless you really know what you’re doing TL;DR If you’re not building for keyboard users, you’re not building for the web. You’re building something that fails the moment real users show up. You don’t need to be an accessibility expert. But you do need to stop shipping things you can’t even navigate yourself. Test with a keyboard. Every time. No excuses.

50

3 Comments

'We only hire senior developers' Congrats! You're building a time bomb. Here's why: Senior-only teams create: • Echo chambers of outdated practices • Zero knowledge transfer • Expensive solutions to simple problems • 10 architects, no builders What you're really missing: • Fresh perspectives • Hunger to learn • Questions that challenge assumptions • Future leaders The brutal truth: • Your 'senior' requirements are fear-based • Your '10 years experience' is arbitrary • Your 'no junior devs' policy is expensive technical debt Why this matters: • Innovation needs new eyes • Growth requires teaching • Sustainability demands succession • AI is leveling the experience gap anyway How to fix it: 1. Hire for potential, not just experience 2. Create mentorship structures 3. Balance your team pyramid 4. Accept that juniors today code better than seniors did 5 years ago Remember: Today's 'risky' junior is tomorrow's 'savior'. What's your take on the senior-only trend? Drop your thoughts below 👇 *** P.S. If your entire team is senior developers, who's asking the 'stupid' questions that prevent stupid mistakes?

93

23 Comments

Don't make the mistake of assuming that, because there's no formal code review (e.g., with a Pull Request) that code isn't being reviewed. It might be that code's actually being reviewed *continuously*, and with much more focus and rigour. For example, when I'm doing TDD, after I've passed the newest test and committed the code, I review the code I've added or changed. And I'm quite systematic about - readability, duplication (Rule of Three), complexity, coupling and cohesion, common code smells (long methods, large classes, divergent change, feature envy and so on. Then I run a linter on the changed files - they can do that, dontcha know? - to look for any low-level issues I might have missed; unused imports, fields that could be immutable, methods that could be private, etc etc. And if there are issues, I refactor. And after each refactoring, when my tests are passing, I review the code again in case my refactoring has made the code worse - e.g., harder to understand - and if it has, I might revert/undo and try something else. And you might be thinking, "Gee, that sounds like a lot of work to be doing 10, 20, 30 times an hour!" But here's the thing: we're talking about a few lines of code in each review. And many issues have already been picked up as that code was being written by my pairing partner. Indeed, quite a few issues are caught before the code's even been written by just talking about what we're gonna do next. Because when you've done a gazillion code reviews, and done them systematically, you basically turn into a human linter. So, no, I don't do formal code reviews. But my code *is* reviewed. A LOT.

56

10 Comments

Anthropic has taken many of the core concepts of Claude Flow and integrated them directly into its new Claude Agent SDK. In my Flow platform, I had to build orchestration around features like artifact tracking, retries, and context persistence because the SDK didn’t provide them. Now those same ideas are native. Tool governance, artifact durability, and context checkpoints are primitives in the SDK. For example, in Claude Flow I wrote custom routines to retry failed tool calls with exponential backoff. The SDK now includes built-in retry handling. I built artifact management so outputs could be stored, versioned, and reused. The SDK now provides artifact durability out of the box. I had to wire in checkpoints to let an agent recover from mid-flow errors. The SDK now exposes context checkpoints directly. This validates the Flow approach. Structured cycles weren’t a workaround, they were the correct abstraction. Developers can now spin up long-running agents without bolting on any orchestration. The friction is lower, the foundation is stronger. At the same time, Anthropic is absorbing practices we pioneered back into its stack. Not that they have given any acknowledgement. Subagents? That was literally our term. The good news is this makes agents easier for newcomers to build, but it also sets tighter boundaries on how Claude agents are expected to work.

182

33 Comments

I realized there's a lot more devs who don't know what S3 presigned urls are, than I initially thought. So let me break down what they are and why you absolutely need them 👇 When you want to upload a file to S3, you typically (serverlessly) use an API endpoint which invokes a Lambda function which uploads that file to your S3 bucket. The issue is Lambda has a 6MB payload limit. This means you can only use Lambda to upload files under 6MB in size. So if you need to upload larger files the easiest way is to use a Presigned URL. Rather than uploading the file itself through Lambda, you instead generate a presigned url and return that to the client-side. Then you can use that url to securely upload your file(s) of much larger size (5GB). It's easy and takes a few seconds to write in your Lambda. 💡 Some best practices of presigned urls: 👉 Use short expirations: anyone can use this url to upload files to your bucket, so keep the url expiration short. 👉 Validate the size and type of the file before uploading: if the file you uplaod isn't the exact same size and type as you define in the presigned url, you'll get an error. 👉 Restrict permissions: ensure the IAM role that generates the url has only PutObject permissions. --- 🔔 Follow Uriel Bitton for more insights on building with the cloud. ♻️ Repost to share it with your network 📬 Subscribe to my newsletter for weekly posts on AWS https://lnkd.in/eUaV8xsr

30