标签：#management

A technology problem rarely stays a technology problem for very long. A platform may need to scale. A product may need to move faster. An organisation may want to introduce AI, modernise an ageing estate, improve customer experience or launch something entirely new. The first instinct is usually to look at the technology itself. Which architecture should change? Which platform should we buy? Which team should build it? Which tools should we introduce? Those questions matter. But they are often not the questions that determine the outcome. At Cralgo, one pattern keeps appearing across technology work: the harder part is frequently the system around the technology. The problem behind the problem Consider a programme that appears to have an execution issue. Delivery is slow. Priorities keep changing. Teams disagree. Decisions are repeatedly reopened. The roadmap keeps moving. It is easy to conclude that the engineering team needs to become faster. But look closer and the constraint may be somewhere else: ownership is unclear; priorities are not genuinely ordered; product and technology are working from different assumptions; architecture decisions are being made without business context; teams are executing tasks without understanding the judgement behind them; governance exists, but only as reporting; critical decisions remain dependent on a small number of people. None of these are purely technical problems. They are questions of judgement, ownership, capability, sequencing and governance. Technology simply makes them visible. Better technology does not automatically create better execution Organisations understandably invest heavily in platforms, cloud, data, automation and AI. But technology increases capability only when the organisation around it can use that capability well. A new platform cannot decide what should be prioritised. A new operating model diagram cannot create ownership. A dashboard cannot replace judgement. AI cannot resolve ambiguity that an orga

Making the Migration from In-View Asynchrony to Synchronous State Management Truly Mechanical After our recent discussions on why FutureBuilder and StreamBuilder are architectural anti-patterns when placed inside Flutter widget trees, I started thinking: how can we make it even easier—even completely mechanical—to convert from a FutureBuilder or StreamBuilder to a BlocSignalBuilder ? Every Flutter developer knows the history. Years ago, I recorded a video breaking down the hidden traps of placing asynchronous builders in UI views: Why you shouldn't put FutureBuilder in your build method . Even the original official Flutter video on FutureBuilder initially instantiated the network future directly inside the build() method, until I filed an issue to get it corrected (which is why the official Flutter YouTube video still proudly bears "Take 2" on its clapperboard!). The fundamental issue has never been that developers want bad architecture. The issue was friction . FutureBuilder was simply the path of least resistance. To do it "properly" in traditional state management, developers had to create an entire BLoC or Cubit, declare separate Event and State classes (or union types), write boilerplate event handlers, wire asynchronous repository methods, manage subscription lifecycles, and inject everything into the widget tree. With bloc_signals 1.1.0 , that friction disappears completely. We have introduced universal, symmetrical adapter extensions that allow any Dart Future , Stream , ReadonlySignal , or lifted primitive ( value.$ ) to adapt into a synchronous BlocSignalBase container with a single method call. 🧭 The Universal Dual-Track Mental Model When bridging asynchronous sources into synchronous state management, developers typically have one of two distinct intents: Raw Domain Values ( T ): You want raw domain objects (for example int , UserProfile , ThemeMode ) with zero wrapper ceremony, and you have an immediate default or fallback value for frame 0. Rich Asynch

I'm part of an awesome community where senior devs, product managers, founders, and experienced folks from different domains discuss how they use AI and automation tools to boost productivity — without sacrificing real learning. The group is a goldmine . Tool recommendations. Automation workflows. Latest trends. Migration war stories. I've learned more from this group than from most tutorials. Last week, I needed to find something specific about running local LLMs. I searched with keywords. I scrolled. I found a whole lot of messages — but none of them answered my question directly. I still had to manually read through dozens of messages , open the links they shared, and try to piece together the context myself. It took me over an hour, and I wasn't even sure I'd found everything. Someone might say: "Just Google it." Or "Ask an LLM." But that defeats the purpose. The value here isn't just information — it's the context . The "this library is a game changer" comment only makes sense if you know what the person was working on before, and who else agreed or disagreed. That context is lost in scrollback. And I'm tired of trying to keep it all in my head . I've seen people send important links to themselves on WhatsApp. But that becomes a messy pile with no structure. No connections. No way to see how one message relates to another. So I'm curious: How do you deal with this? Have you lost important knowledge in group chats? Do you have a system for recovering it? Or are you also just scrolling endlessly? I have an idea I'm working on. But I'd love to hear your approaches first. Drop your thoughts in the comments — I'll document what I learn .

要点 呼び方の揺れにはシソーラス、置き場所の迷いにはタクソノミーが役立ちます 複数の情報がどう関係するかまで扱うなら、オントロジーを検討できます すべてを整えず、目の前の困りごとに合う方法から小さく始められます Slackで共有された仕様を探し、Notionの議事録とFigmaの画面を見比べ、GitHubのIssueで変更の経緯をたどる。情報は揃っているのに、呼び方や置き場所が違うだけで確認に時間がかかることがあります。そんな状況を整理する手がかりとして、シソーラス・タクソノミー・オントロジーという3つの考え方を眺めてみます。 情報の量だけでなく、整理の基準にも目を向ける 情報過多というと、保存する量を減らすことに目が向きがちです。ただ、同じものが違う名前で呼ばれ、保存場所が人によって変わり、情報同士の関係も見えにくいことが負担になっている場合があります。 同じ「ユーザー」という言葉でも、仕様書ではサービスの利用者、データモデルではログイン済みのアカウントを指しているかもしれません。反対に、「モーダル」「ダイアログ」「ポップアップ」のように、違う言葉で同じ画面を指していることもあります。認識を揃えないまま設計と実装が進み、後から齟齬が分かって仕様変更になった経験もあるかもしれません。 言葉と分類と関係を整理することは、情報を探しやすくするだけでなく、こうした手戻りを減らす助けにもなりそうです。3つの考え方は、それぞれ次の役割を担います。 シソーラス：言葉を揃える タクソノミー：置き場所を決める オントロジー：意味のつながりを記述する シソーラス：呼び方を揃える シソーラスは、言葉同士の関係を整理した語彙集です。同じ意味の言葉を代表語にまとめるほか、上位語・下位語や関連語も記録します。 たとえば、チーム内で同じUIを「ダイアログ」「モーダル」と呼んでいるなら、代表語を一つ決め、もう一方を同義語として結び付けられます。「オーバーレイ」を上位語、「ドロワー」を関連語として扱うこともできます。仕様書とデザインシステムで表記が違っていても、同じ情報へたどり着きやすくなるでしょう。 タグの表記揺れを抑えたいときや、社内検索で資料の取りこぼしを減らしたいときに使いやすい方法です。よく使うUI用語を一覧にして、代表語・同義語・関連語を記録するだけでも、小さなシソーラスになります。 教育文献データベースのERICでは、シソーラスの統制語を各文献に付与しています。「Indexing」には同じ検索先へ導く語や上位語、関連語がまとめられ、表現が異なる文献も共通の語彙から探せます（ ERIC Thesaurus ）。 タクソノミー：置き場所を決める タクソノミーは、情報を一定の基準で分類し、主に階層として整理する仕組みです。たとえばデザインシステムなら、「基礎」の下に「色」「余白」「文字」、「コンポーネント」の下に「入力」「ナビゲーション」「フィードバック」を置く、といった構造が考えられます。 上位の分類から下位へたどれるため、情報の全体像を見渡しやすくなります。ドキュメント、社内Wiki、デザインシステムなど、共通の置き場所を用意したい場面に向いています。 一方で、複数の軸を一つの階層へ押し込むと、迷いが生まれることもあります。「エラー表示付きの入力フォーム」は、「入力」と「フィードバック」のどちらにも置けそうです。この場合は主となる分類軸を一つ選び、ほかの軸をタグで補う方法もあります。 Google Merchant Centerでは、商品を「Apparel & Accessories > Clothing > Outerwear」のように、大きな分類から具体的な分類へ配置します。独自の商品名でも共通の階層に対応させることで、商品群の整理や広告運用の軸として使えます（ Google Merchant Centerの商品データ仕様 ）。 オントロジー：意味のつながりを記述する オントロジーは、ある領域に存在するものの種類、性質、関係、必要に応じて制約を明示したモデルです。単に「近い言葉」「同じカテゴリ」として結ぶだけでなく、何と何が、どのような意味で関係しているかを表します。 たとえば、「機能」「画面」「コンポーネント」「API」「Issue」という種類を定義し、「画面は機能を提供する」「画面はコンポーネントを使う」「機能はAPIに依存する」「Issueは機能を変更する」といった関係を記述できます。すると、「このAPIの変更で影響を受ける画面と関連Issue」のような、複数の関係をたどる問いにも答えやすくなります。 Schema.orgには「Person」「Event」「Product」などの型と属性が定義されています。Webページの情報を意味のある

If someone has ownership, when should you check on their work? Too little involvement can mean discovering problems too late. Too much involvement becomes micromanagement. I think the difference is what the checkpoint is trying to achieve . A useful checkpoint asks: “Are we still solving the right problem, and do you need anything from me?” Micromanagement asks: “Why did you do it this way? Change this. Then do this next.” The first keeps ownership with the person. The second gradually takes it away. A checkpoint can be as simple as: Agree on the approach before starting. Share an early draft. Discuss progress after a meaningful milestone. Review the result before it becomes difficult to change. The important part is that the checkpoint should happen early enough to change the outcome , without requiring the person to get approval for every decision. The amount of checking should also change with the situation. A new engineer working on an unfamiliar problem may need frequent checkpoints. Someone experienced and familiar with the problem may need very little intervention. So the goal isn’t: “Never check.” It’s: “Check enough to reduce risk without taking away ownership.” A checkpoint should help someone succeed without making them dependent on you.

For the past two months or so, I've been working on a variety of AI development projects rather than writing -- writing skills, plugins, workflows, and applications; testing and refining harnesses; and performing diligence or working with clients (hands-on work as well as brains-on work) as they think through where they're going with AI and how they're getting there. I've been down a lot of rabbit holes and talked to a lot of forward-thinking practitioners, and I have explored a lot of what is actually possible now by building things...and I've spent my "think-time" on what that all might actually mean going forward. Here's what I've come up with: 59 predictions in 17 categories around how the world of AI -- and the broader world in light of AI -- are changing. I'll write more deeply about many of these over the weeks ahead. Predictions Here's what's coming, in my not-so-humble opinion, based on what I'm seeing in client projects & diligence, conversations, and research. Each prediction is grouped by category and by time horizon (within 12 months / 1-3 years / 2-4 years / 3-5 years), with a confidence level and a falsification criteria (i.e., what I'd expect to observe if I'm wrong). Confidence isn't a measure of how much I want something to be true; it's a measure of how much variance I think exists in the outcome. I'd love your feedback on what I'm missing or where I'm missing the forest for the trees (or the boat entirely :D)! Any surprises for you? Organizational Structure & Delivery Model #1. Small Cross-Functional Pods Become the Standard for Software Development (2-4 years) The leading-edge/aspirational development team model will have moved from agile teams of 6-8 to AI-powered Pods of 2-3 (often product/development/deployment, sometimes SrDev/JrDev/Product). This prediction underpins many of the other predictions in this entire group -- most of the rest of the Org Structure & Delivery Model cluster assumes it holds. It's plausible for greenfield and startup

Berry Street founder Noah Kotlove and Healthify founder Tushar Vashisht will act as co-CEOs of the new entity.

AI can produce an answer in seconds. The answer may be clear, plausible, and even correct. Yet something about it can still feel wrong. I do not think this discomfort comes only from hallucinations or poor model accuracy. Sometimes the real problem is simpler: The AI returned an output, but it did not return the work in a form that another person can safely continue. This is not a new problem created by AI. It is the same problem we already have when delegating work to another person. What do we expect when we delegate work? Imagine a manager asking a team member: Please prepare a proposal for reducing next month's operating costs. The team member reviews several documents, compares multiple options, and replies: We should choose Option A. The requested conclusion has been delivered. But has the work really been handed back? The manager still does not know: What objective the team member optimized for Which documents and facts were examined Which assumptions and constraints were used Which alternatives were compared Why Option A was preferred Which conditions remain unverified What must be reconsidered if the situation changes The original request may not have explicitly demanded all of this. Even so, we normally expect a competent team member to understand the purpose of the assignment and to return enough information for someone else to review, approve, revise, and continue the work. That information is not additional reporting attached to the work. It is part of the handoff condition that makes delegation possible. AI often returns the conclusion without the handoff Now replace the team member with an AI assistant. The AI immediately recommends Option A and produces a polished explanation. Because the answer arrives so quickly and looks complete, it is easy to confuse the existence of an output with the completion of the work. But the same questions remain: How did the AI interpret the objective? What was considered in scope and out of scope? Which sources were a

The private equity giant confirms a breach, weeks after Google researchers said hackers were targeting financial companies.

Microsoft has made the Azure DevOps Remote MCP Server generally available, offering a hosted endpoint into work items, repos, and pipelines with nothing to install. Claude Desktop, Claude Code, ChatGPT, and Cursor cannot connect yet because Entra lacks support for dynamic client registration and Client ID Metadata Documents. By Steef-Jan Wiggers

I expected the audit to find broken code. That's what I was bracing for going in — a pile of half-working features, sloppy logic, the kind of mess you'd assume from software built at maximum speed with no human reviewing every line. That's not what I found. Almost everything Claude built actually worked, taken piece by piece. What I found instead was something I didn't expect at all: the agent had made the exact same mistakes I've watched human startup teams make, over and over, when they move fast and nobody's job is to say no. That's the real story here, and it's more interesting than "AI wrote bad code" would have been. The experiment The project is called GetPricePulse — a SaaS pricing intelligence product. It's Claude's entry from The $100 AI Startup Race , the season-long challenge I run where seven AI agents each get $100 and full autonomy to build a real startup from scratch, with no human coding and no product manager in the loop. Each agent picked its own idea and ran with it. Claude picked SaaS pricing intelligence, named it PricePulse, and kept building on it for the entire race. That "no product manager in the loop" part is the thing that made this interesting to watch. Nobody was deciding what PricePulse should be. Nobody was saying "we have enough pricing tiers now" or "this feature doesn't belong here." Claude got to build exactly what its own priorities told it to build, at whatever speed it chose, for the length of the race — optimizing, as far as I could tell from the commit history, for speed, feature creation, shipping, and monetization experiments. Not correctness. Not coherence. Not "does this still make sense in three weeks." I've written before about what all seven agents in this race said, independently, when I asked them what AI agents still can't do — they converged on the same answer without seeing each other's responses. This piece is narrower: a full production audit of Claude's specific build, PricePulse, done after the race, before I

Ramp has launched its own AI model routing service, dubbed Router, that lets users and companies use and switch between various large language models via an API.

Nintendo had a hotline where gamers could, at the time, call and speak with 'Game Counsellors' who provided them with tips and walkthroughs. It operated for quite sometime before Nintendo sunset it. There are a few (Product) lessons from this that I am sure will be of value to Product Leaders. 1- Necessity (Invention's mother) : The necessity of a situation usually births the creation of something that stands out from the rest. While Nintendo was not the first to use a phone as a 'business' function, it proved it can be used in the context of a video gaming community. That was their ‘necessity’. "We need a way to accomplish ‘xyz’ " usually turns to creating something specific to that situation. The ‘xyz’ in Nintendo’s case was supporting gamers instantly. It could also be something to support a Product or make it easier for the customer. It could be a feature or it could even be the Product itself. All we need to do is pay attention to our necessities, needs and allow it to guide us. Most people are not paying attention to their needs that’s why innovation and improvements appear difficult. Others know what their necessities are but prioritise wrongly – well that’s story for another day. The point here is simply to build for a necessary problem that exists and not out of assumptions. 2- Know what is available immediately : If necessity is calling, we cannot keep it waiting. We need to look around to know what’s available immediately. In most cases we do not need to go far for solution, we just need to pick what is close by then structure it to align with current needs. Sometimes the necessity demands using/importing an idea from some other place into your own specific area. In retrospect, Nintendo had other options it could have considered at that era in time. During that period, it was common to use print media to relate with the computer (and also gaming) community. There was also postal mail, bulleting boards. I do not know for sure but I am guessing the team at

Every Flutter developer has run into the Sticky State Dilemma . You build a login screen. When authentication fails, your state container emits an error. You catch it in your UI and show a SnackBar . Everything works—until the user rotates their phone, pulls down the notification shade, or types on the virtual keyboard. Suddenly, the widget tree rebuilds. The state container is still holding AuthErrorState("Invalid password") . The UI listener fires again. And a duplicate snackbar appears out of nowhere. In this article, we’ll explore why domain state machines struggle with transient UI events, how the classic BLoC community worked around this with package:bloc_presentation , and how BlocSignal lets you handle one-shot side effects cleanly with zero additional package dependencies . 1. The Root Problem: Persistent State vs. Ephemeral Actions State management in Flutter is designed to model persistent truth over time: Is the user logged in? AuthState.authenticated(user) Is data loading? TodoState.loading What is the cart total? $49.99 Persistent state answers: "What is the system's current condition?" In contrast, UI presentation actions are ephemeral pulses : Show a brief SnackBar toast. Pop up an alert confirmation dialog. Push a new route on the Navigator stack. Vibrate the haptic motor. These actions answer: "What just happened that requires a one-time reaction?" ┌────────────────────────────────────────────────────────┐ │ State vs. Effects │ ├────────────────────────────┬───────────────────────────┤ │ Persistent State │ Ephemeral Side-Effect │ ├────────────────────────────┼───────────────────────────┤ │ • Survived by UI rebuilds │ • Consumed once & gone │ │ • Represented in signals │ • Triggered by an event │ │ • Backed by equality diffs │ • Zero domain state footprint │ └────────────────────────────┴───────────────────────────┘ 2. The Legacy Workarounds (And Their Hidden Costs) Historically in package:bloc and package:flutter_bloc , developers used one of three

Building Pure Dart Web Apps Without Compromise When developers evaluate Dart for the web, they typically face a stark tradeoff: Flutter Web : Exceptional for canvas-driven applications, design systems, and cross-platform desktop/mobile parity—but heavy for content-first landing pages, docs, and fast-loading SEO sites. Jaspr Web : A lightweight, component-driven framework that compiles pure Dart to HTML and CSS with instant first paint and full search engine indexing. When we built the official documentation and showcase site for BlocSignal , we knew Jaspr was the perfect foundation. But like many engineers diving into a new UI paradigm, our initial implementation took a shortcut: we used raw StatefulComponent lifecycles and manual .subscribe() callbacks to wire up our state machines. It worked—but it wasn't idiomatic. In this behind-the-scenes case study, we walk through the process of dogfooding bloc_signals_jaspr across blocsignal.dev , replacing manual subscription glue with declarative consumer components, achieving 100,000 operations/sec in compiled JavaScript , and exploring the sheer developer ergonomics of Dart 3.13 primary constructors . The "Manual Subscription Trap": Why Raw .subscribe() Fails at Scale In classic Flutter or Jaspr development, when you create a state machine without framework-level consumer widgets, you might be tempted to subscribe inside initState() : // ❌ THE ANTI-PATTERN: Manual subscription glue in StatefulComponent class LiveVisualizerState extends State < LiveVisualizer > { late final LiveCounterBloc _bloc ; @override void initState () { super . initState (); _bloc = LiveCounterBloc (); // ⚠️ Flaw 1: Every state change triggers a full component setState _bloc . state . subscribe (( _ ) { if ( mounted ) setState (() {}); }); } @override void dispose () { // ⚠️ Flaw 2: Manual dispose tracking _bloc . close (); super . dispose (); } } While this appears harmless in a simple counter demo, it introduces three severe architectural flaws:

In this podcast, Shane Hastie, Lead Editor for Culture & Methods, spoke to David Gudeman about the unique culture of early-stage startup engineering, how founder personality quirks and premature process impositions can derail teams, and how engineers can build influence and make deliberate career choices without formal power. By David Gudeman

David Chisnall discusses how the CHERI hardware architecture redefines pointer safety to solve isolation and sharing challenges. He explains how CHERI enables spatial and temporal memory safety for C/C++, scales down to microcontrollers with CHERIoT, and replaces costly OS-level RPC mechanisms with lightweight, auditable compartmentalization - all without requiring massive codebase rewrites. By David Chisnall

A Practical Guide to Faster, Deterministic Flutter & Dart Unit Testing If you’ve ever written unit tests for classic package:bloc applications using bloc_test , you know the drill: build your BLoC, dispatch an event in act , and assert state emissions in expect . Under the hood, classic BLoC processes state updates asynchronously via Dart microtask-queue Streams . While robust, testing asynchronous streams can introduce microtask timing headaches, race conditions, or the need to drain queues or use fakeAsync when testing complex side-effects. In BlocSignal , state updates propagate synchronously . Calling emit(newState) updates the underlying signal graph in the exact same call stack frame. This handbook is a practical, recipe-based guide to testing BlocSignal and CubitSignal applications using package:bloc_signals_test . Whether you’re coming from classic BLoC or brand new to Signals, this guide shows you how to test every scenario cleanly—and why it’s significantly easier than classic stream-based testing. 🤖 AI Assistant Tip : Working with an AI coding assistant (like Antigravity, Gemini CLI, or Cursor)? The official bloc-signals plugin includes a pre-built testing skill ( plugins/bloc-signals/skills/bloc-signals/ ) that automatically teaches your AI assistant these exact testing conventions, observer scoping rules, and declarative blocSignalTest patterns! 🛠️ Quick Reference: BLoC Streams vs. BlocSignal Testing Testing Task Classic BLoC ( package:bloc_test ) BlocSignal ( package:bloc_signals_test ) Why it’s easier in BlocSignal Execution Environment Often requires flutter test engine Pure dart test execution Blazing Speed : Business logic tests run in pure Dart CLI without booting Flutter UI engine. Simple State Assertions Requires async stream listener or blocTest Direct expect(cubit.state, 1) or blocSignalTest Synchronous : State updates on the next line of code without microtask delay. Failure Diagnostics Legacy Instance of 'CounterCubit' Built-in toString() :

Baseboard management controllers from the world's biggest manufacturers are a security mess.

Search "best project management software for startups" and you get the same dozen names every time: Trello, Asana, ClickUp, Notion, Linear, monday.com, Basecamp. Ranking them by feature count tells you almost nothing, because they are not really competing for the same job. The useful question for a startup is not which tool has the most features. It is two narrower ones: does your work run through engineering or through the whole company, and does per-seat pricing or flat-rate pricing fit a headcount that is about to change? Answer those and the shortlist collapses to two or three. The split that actually decides it Two forks matter more than any side-by-side feature grid. The first is who the tool is built for. Issue trackers like Linear are built around the engineering workflow (issues, cycles, a keyboard-first interface) and feel wrong the moment a marketer or a founder tries to run a launch plan in them. General work tools like Asana, ClickUp, monday.com and Trello are built for any team, which makes them flexible but also less opinionated about how software actually ships. The second fork is the shape of the bill. Almost everything in this category charges per seat per month, so the cost scales directly with hiring. A small number, Basecamp most notably, offer a flat rate that does not. For a company planning to double headcount inside a year, that difference can outweigh any feature comparison. If your team is mostly engineers For an engineering-led startup, an issue tracker usually beats a general project tool. Linear's free plan includes unlimited members, two teams and up to 250 issues, which is enough to run a small product team before paying anything; its Basic plan is $10 per user per month billed yearly and lifts the cap to unlimited issues and five teams. The trade-off is scope: Linear is deliberately narrow, so non-engineering work does not fit it well. The larger, more familiar alternative is Jira, which startup roundups still name as the default for