Henrik Johansson

🚀 Just Published: @deathbycode/civitas-id-sweden on npm! I’m excited to share that I’ve published @deathbycode/civitas-id-sweden — a JavaScript/TypeScript package for working with Swedish personal identity numbers (personnummer) and coordination numbers. Handling Swedish IDs correctly isn’t trivial — there are validation rules, Luhn (mod10) checks, date logic, coordination number offsets, gender parsing, and formatting nuances that are easy to get wrong. This package aims to make that simple, accurate, and developer-friendly. ✅ Features • Validate Swedish personal identity and coordination numbers • Parse date of birth and gender • Built-in mod10 (Luhn) checks • TypeScript-first API • Lightweight and easy to integrate Whether you’re building fintech apps, internal tools, or identity-aware services — this package helps you confidently handle Swedish IDs with minimal fuss. 🔗 npm: https://lnkd.in/d7V-qjT7 💻 GitHub: https://lnkd.in/dZBZPrdC I’d love your feedback, issues, or contributions — let’s make this even better! 🙌 #javascript #typescript #npm #opensource #sweden #personnummer #developer

14

I hope that this encourages organizations to explore inviting programmers into a more participatory role in developing the entire product. I worry that less-experienced programmers will become stuck in these "paid to write good-enough code" jobs and never develop the skill and interest in taking a greater role in product development. Meantime, the programmers who can do this well will all die or, like Justin here, grow tired of the industry, then quit. Not everyone who writes software wants to become a product-oriented entrepreneur. For example: I don't.

21

3 kommentarer

SAFe - Agile Architectural Principles from an earlier SAFe class from versions ago: I reread "Lean Architecture for Agile Software Development" over the weekend. Thank you James Coplien & Gertrud Bjørnvig with your SO MANY great insights. And I reread it to remind myself of all of those insights. And in my nth reread of Lean Architecture I still find so much value. Honestly I was looking for a list of software development architectural principles to compare my current list against and stayed to go through it again. Here is a list of agile architectural principles we used in SAFe classes many versions ago. This was from a v3 SAFe class. Agile Architecture Principles Principle #1 The teams that code the system design the system. Principle #2 Build the simplest architecture that can possibly work. Principle #3 When in doubt, code it out. Principle #4 They build it, they test it. Principle #5 The bigger the system, the longer the runway. Principle #6 System architecture is a role collaboration. Principle #7 There is no monopoly on innovation. Again, these are from several years ago. A question for you. What are you using as your list for your achitectural discussions with the system architects, portfolio architects, and enterprise architects you are working with today? The folks I work closely with often joke how I always go back to Reinertsen or Ward! For you, yes I do have a larger reading list! And yes, I do have my list of architectural principles for lean product development (not just for software development). Here's my next question, and yes, I am looking for comments. What is an architectural principle driving your discussions, toward the top of your head today. For software dev or product dev wherever your thoughts head. john ps. And yes, in a future post, I will share my current list. Doug Kathy Charlene Charlene Christopher Mark Mark Mark Dr. Adam Steve Steve Michael Harry Daylon Katie Blake Luke Keith Rosana (Ro) Karen Scott Scott Niraj Kiran Martin Phil Travis Terry Jane William Steve Rick Mark Dr. James Neil Dee

13

31 kommentarer

Thursday thoughs: (This is a fun topic for me excuse the excitement) 🤓 Why Linear Thinking in Systems Design is a Trap (And How to Avoid "Effect C") In my journey as a software developer and solution architect; whether tackling challenges at Klart.se or building in general, I’ve learned that rigid, linear thinking is rarely the right tool for complex problems. We often approach a project with a simple goal: Go from Point A to Point B. We execute the plan, we reach Point B, and we celebrate. But then we look around and realize that in our single-minded rush, we inadvertently created "Point C." Point C is the technical debt we didn’t account for. the user friction we introduced or the scalability issue that only appears six months later. It’s the result of asking "How do we get there?" without asking "What happens to the environment when we move through it?" Systems design shouldn't be a straight line; it should be like water. Water doesn't force its way through an obstacle in a straight line; it shapes itself to the environment. It fills the gaps, flows around barriers, and finds the most efficient path without breaking the container. To avoid the "How did we end up here?!" moment, we need: 1. Fluidity over rigidity: Adapt the architecture to the specific case, not the other way around. 2. Diverse perspectives: Inclusion isn't just a buzzword; it's a debugging tool. The more angles we view a problem from before we build, the fewer "Point C" surprises we encounter later. Next time you’re designing a solution, ask yourself: Are we just trying to hit the target, or are we considering the ripples we’re creating along the way? PS: One thought on Efficiency: People often ask, "Isn't this slower? Isn't linear thinking more efficient?" My answer: Efficiency is doing things right; Effectiveness is doing the right things. There is nothing less efficient than efficiently building something that breaks the system or that users don't need. Real efficiency isn't just speed; it's sustainable speed. I take the chance to bring up a video featuring Russell Ackoff, one of the fathers of Systems Thinking, explicitly explaining why we shouldn't confuse efficiency with effectiveness. https://lnkd.in/dBusF_kz #SystemsDesign #SoftwareArchitecture #stockholm #LinearThinking #TechLeadership #WebDevelopment #AtlasLejon #Leadership #innovation

14

4 kommentarer

𝗧𝗵𝗲 𝗗𝗲𝘃𝗲𝗹𝗼𝗽𝗲𝗿'𝘀 𝗣𝗮𝗿𝗮𝗱𝗼𝘅 I know a top software architect who lost his job last year. He had 15 years of experience building complex systems for big clients. But when he left, he had little to show for it. This is because of NDAs and client ownership clauses. You may have felt this tension as a developer. The more specialized your work is, the less portable it is. I call this the Builder's Paradox. You have deep expertise that is invaluable but invisible outside your organization. Most developers have one employer and one income stream. This is a single point of failure. We wouldn't design a system this way. We'd build in redundancy and failover mechanisms. To avoid this, you can: - Write about a problem you solved without naming the client - Create a small open-source tool - Test a small product idea on the side Over time, this work becomes proof of your thinking. It's not about working 60 hours a week. It's about being deliberate with your time. Think of your career like a system design. No investor puts everything in one stock. So why put all your professional leverage in one employer? You'll stay sharper and think more strategically. You'll bring back ideas that improve how you lead teams. Start by writing about something you solved this week. This creates an asset that exists independently of your employer. Source: https://lnkd.in/gC7vQ_XW

1

Together with Erik-Jan Westendorp, we developed a modular extension for Umbraco 16+ that enhances Umbraco Forms cleanly and flexibly. The idea was simple: make forms more powerful without making them more complex. By keeping everything modular, you can enable only what you need and extend it further when required. What the extension helps with: - Extending Umbraco Forms without touching core functionality - Adding reusable, modular building blocks for form logic - Keeping implementations maintainable and future-proof - Making it easier for teams to adapt forms to project-specific needs This kind of work comes from our shared passion for Umbraco and the opportunity at ilionx to apply that knowledge in real client solutions. Curious about the technical details and the thinking behind this approach? Read more here: https://lnkd.in/eTFs_Tvm

25

🚀 Why E2E Testing with Playwright Matters I was recently testing our “Create Fixed Shift Template” feature, and I ran into a tricky issue. Even though certain items were clearly visible on the UI, Playwright sometimes couldn’t detect them, causing the test to fail. At first, it was puzzling everything looked fine to the eye, but the assertions kept breaking. 💡 What was going on? After reviewing the CI/CD test video recordings carefully and paying attention to minor details, I realized the problem was UI lag when rendering a large number of shifts at once. In production, users usually have fewer shifts, so this never happens there. ⚡ How I solved it: I implemented a pagination and virtualization so that only the visible items are rendered at a time. The results were immediate: 1. Tests became stable. ✅ 2. UI performance improved. ⚡ 3. Users got a smooth and responsive experience, which also builds trust in the system. 💪 ✅ Takeaways: 1. E2E tests catch issues that unit tests often miss. 2. Virtualizing large lists and rendering only visible items boosts the user trust, while keeping the app fast. E2E testing isn’t just about catching bugs it’s about ensuring your users have a smooth, consistent, and trustworthy experience every time they interact with your product. #Playwright #E2ETesting #ReactJS #UserExperience #CodingBestPractices

19

5 kommentarer

New post on Swift & Sour! 📦 I dive into the world of static and dynamic code, exploring how frameworks, libraries, and linking shape the way apps are built and loaded. 🌐 Read it here: https://lnkd.in/dCbhmiks #Swift #iOSDevelopment #Frameworks #Xcode

19

Developers don’t become leaders by accident. When I first stepped into leadership, nobody handed me a playbook. I had to piece it together by watching the managers around me — the great ones, the average ones, and the ones who taught me exactly what not to do. That’s when it hit me: the skills that got me here weren’t the skills that would help me succeed next. I had to learn how to: – communicate with clarity – influence without authority – set direction instead of diving into the code – coach instead of fix – deliver outcomes through a team, not through my own keyboard. None of that was obvious at the start. But once you see the shift, you can’t unsee it. If you’re a developer stepping into leadership, you’re not alone — and you don’t have to figure it out the hard way as I did. What have you had to figure out as a manager?

9

Many people tell me that ChatGPT feels different from M365 Copilot — even though it’s powered by the same underlying LLM. Some even claim it’s not the same LLM at all. Let me put it this way: I once owned a Citroën C4 with a BMW engine — the very same engine found in some BMW 3 Series models. From my own experience, I can tell you: the C4 drove very differently than a 3 Series BMW. The C4 felt much more as a comfortable family van. It’s exactly the same here. #M365Copilot is optimized for business use — and it’s not just about GDPR or data residency. It’s also about how the answers are shaped and delivered. This business-focused approach to an LLM is truly unique right now. 🚀

5

3 kommentarer

Most developers spend their time optimizing code, but the real issue often lies elsewhere. The biggest bottleneck in software development is unclear requirements not bad code. Before you start writing, make sure you can explain the problem clearly. If you can’t, don’t code it yet. A few minutes spent clarifying can save days of debugging.

27

3 kommentarer

It's not a skills gap. It's a "wait, AI can do THAT?" gap. My team and I at Sana update our workflows with every new model and feature drop. And not because we're nerds (okay, partly because we're nerds). 🤓 But it's repeatedly given us 20-30% productivity gains. Our learning designers work completely differently now. Here's the honest part though. We still spend a lot of time teaching partners the basics. That tells you where most orgs are. And I don't say that to be harsh because people are genuinely eager to catch up. That's the part worth building on. 🔥 So here's what I can recommend. Write down what you think AI can handle in your L&D workflow. Then ask that same AI to prove you wrong. The gap between your assumption and reality might surprise you. #LearningAndDevelopment #FutureOfWork

36

3 kommentarer

Day 1 – Understanding the Cascade Many frontend teams underestimate how much time they could save by better understanding the CSS Cascade. The Cascade is not just a set of rules, but the core mechanism that determines how browsers make decisions. Those who understand how Importance, Origin, and Specificity interact write CSS that is more consistent, predictable, and resilient in the long run. The Cascade is not an opponent to be outsmarted – it is a system to work with. Solid CSS starts not with frameworks or tools, but with understanding these foundations. #CSS-Advent-Calendar #CSS #Web-Development https://lnkd.in/ePCBq6Us

7

Second speaker for the Malmö meetup is locked. We are happy to have Emma De Silva back again, this time with security in focus. Read more below and signup at https://luma.com/0tqpue31 ---- *Think Like an Adversary: OPSEC for Laravel Developers* Brief: Most Laravel security talks stop at the code. This one goes further. Drawing from real-world corporate cybersecurity experience and formal operations security training, this talk takes developers beyond framework-level defenses and into the organizational and infrastructure thinking that determines whether a breach is a minor incident or a disaster. Whether you're a solo founder deploying your first SaaS or part of an enterprise team, these OPSEC principles protect your Laravel app where the framework can't.

4

After 3 years of a side project living in “I’ll finish it someday”-land, I finally launched it — and it only took two evenings with AI. I’ve just published: 👉 https://blind-code.vlx.dk/ The first version (3 years ago) was basically a rough PoC: core functionality, zero polish, missing all the “final touches”, and absolutely not something you’d show anyone unless you enjoy embarrassment. Then life happened. The project kept getting deprioritized while I focused on my role as Chapter Lead — helping the team, supporting shared architecture, and improving ways of working instead of shipping personal projects. This week I picked it up again. With Claude Code, it went from forgotten PoC to finished site in two evenings. A bit about the game itself: In a world where we’re getting further and further away from HTML and CSS — wrapped in abstractions, generators, and AI prompts — this is a small reminder that those core skills still matter. CSS has been around since 1996, and it’s still very much alive. This game is a simple, practical way to train and keep a skill that many of us quietly rely on every day, even if we don’t write it by hand as often anymore. My honest take on working with Claude Code: It’s very good at executing your vision — if you actually have one. It’s not magic and definitely not autonomous. It happily picked a Next.js version with a known vulnerability. The design defaults are… impressively generic. It loves big files and repeated Tailwind because it only reasons one file at a time. Translation: AI doesn’t replace experience — it just moves faster in the wrong direction if you don’t steer it. The site itself is intentionally simple. It’s not a design award winner — it’s a shipped product. And honestly, shipping > perfect. It’s also a good example of how I work: clear intent, pragmatic choices, and actually finishing things instead of endlessly “iterating”. If you’re curious about AI-assisted development, modern frontend workflows, or how experienced developers can use these tools without letting them create beautiful technical debt — feel free to take a look. 👉 https://blind-code.vlx.dk/ #css #html #javascript #frontend #AI #NextJS

50

4 kommentarer

Engineering Leader’s Guide: How to Become a Great Coach and Mentor Being a great coach and mentor is crucial. Learn how to become one the RIGHT way! An article by Gregor Ojstersek && Andy Skipper https://lnkd.in/g8rahQ4T

6

1 kommentar

Ready to learn some practical DSP? If so, we invite you to join us for tomorrow's The Audio Programmer Meetup! We will be joined by Musik Hack Co-Founder Sam Fischmann. Sam has had great success with well known plugins such as Master Plan and Fuel. We will be talking about useful DSP. Including... ✅ Filter basics, frequency and phase, not just frequency! ✅ Filters, when to use (IIR/FIR/linear/minimum phase/biquad forms/svf) ✅ Filter shapes, when to use (bessel, butterworth, chebychev 1+2 , elliptical/cauer/Linkwitz Riley/clamping) ✅ Filter implications for null tests and parallel processing ✅ Oversampling + aliasing ✅ Desmos for testing and comparing saturation techniques ✅ Saturation myths: Harmonic and inharmonic distortion ✅ Basic compressor/limiter design This will be a great conversation for anyone who is seeking to gain an overall understanding of how DSP algorithms work, and how to use them. Tune in here: https://lnkd.in/e9wxeA9h

57

8 kommentarer

AI coding didn’t evolve. It re-architected the software workflow. Most discussions treat AI as a better autocomplete. That’s not what changed. What changed is where AI lives in the development lifecycle, and what authority it’s given. Generation 1 - Chat Helper AI sits outside the system. You paste code. It explains. You decide. You execute. Helpful - but completely disconnected from reality: • no repo context • no tests • no accountability AI has opinions, not ownership. Generation 2 - IDE Copilot AI moves into the editor. Token prediction. Inline completion. Human-in-the-loop control. This is where productivity spikes, but responsibility does not move. The developer still owns: • correctness • testing • integration • failure AI accelerates keystrokes, not outcomes. Generation 3 -Task Agent This is the real inflection point. AI gains tool access: • repositories • search • build systems • tests • CI pipelines You stop asking how to do something. You give a goal + constraints. The agent plans, executes, iterates, and stops only when checks pass. The output isn’t code. It’s a pull request with evidence. This is where AI stops assisting and starts owning slices of work. Generation 4 - Governed Agent This is where most teams hesitate, and where scale actually happens. Autonomy without control doesn’t survive production. Here, agents: • operate under permissions • run in sandboxes • pass eval & policy gates • emit audit trails • support rollback paths This isn’t “AI coding.” This is AI becoming part of the software control plane. The key insight The progression is not: weak models → strong models It’s: suggest → complete → execute → execute with proof The hardest problems ahead are not: • prompting • model selection • token limits They’re: • trust boundaries • blast-radius control • evaluation design • ownership of automated decisions Most teams are experimenting at Generation 2. Most value unlocks at Generation 3. Most risk lives at Generation 4. The winners won’t be the teams with the smartest agents. They’ll be the teams who understand where autonomy must stop. If you’re building with agents today: 👉 what’s your biggest blocker, tooling, trust, or governance? #SoftwareEngineering #AIAgents #DeveloperTools #PlatformEngineering #LLM #DevOps #MLOps #AIEngineering #EngineeringLeadership #Automation #SoftwareArchitecture #PlatformEngineering #AIOps #DevSecOps #CI_CD #AgenticAI #LLMOps #Observability #Governance #SecureByDesign

5