标签：#c

wa.me/username doesn't work yet — I verified it two ways, here's what to use instead If you've tried to build a "share my WhatsApp" link using a @username instead of a phone number, you've probably assumed wa.me/username (or wa.me/u/username ) works the same way wa.me/15551234567 does. It doesn't — at least not yet, as of writing this. I wanted a definitive answer instead of trusting blog posts or AI chatbot answers (more on that below), so I tested it two independent ways. Test 1: server response curl -I https://wa.me/u/some_real_reserved_username Every username path I tried — including a certified-real, currently-reserved username — 302-redirects to: api.whatsapp.com/resolve/?deeplink=...&not_found=1 Compare that to the phone-number path, which redirects to: api.whatsapp.com/send/?phone=...&type=phone_number Different resolver, different outcome. The server-side route for usernames exists, but every lookup currently resolves as "not found" — even for real, live usernames. Test 2: real device Server response alone doesn't rule out Universal Links / App Links intercepting the URL client-side before it ever hits a server — curl can't see that. So I also opened all three link variants ( wa.me/username , wa.me/u/username , and a redirect through my own domain) on a real phone with WhatsApp installed. None of them opened a chat. Why this matters if you're building anything around WhatsApp usernames WhatsApp has rolled out @username handles as a real, user-facing feature — but it hasn't published a public deep-link spec for opening a chat from one, the way it has for phone numbers for years. If you're building a tool, a profile page, a business card generator, anything that assumes wa.me/username "just works," it doesn't, for anyone. One more data point: I asked Meta AI directly about this, with the counter-evidence above in hand. It kept asserting the link already works and didn't engage with the evidence when pushed. That's a useful reminder that chatbot answers about

Governance is not a set of rules layered on top of AI. It is the structural logic that determines how meaning, constraint, and legitimacy are maintained as the system accelerates. If Pillar 1 establishes the need for a sovereign semantic foundation, Pillar 2 defines the governance architecture that must sit above it — not as oversight, but as physics. The Perception Governance is often treated as a reactive discipline: policies, audits, compliance frameworks, risk registers, and oversight mechanisms designed to keep AI “within bounds.” This assumes governance is something external — a supervisory layer that watches, corrects, and intervenes when systems behave unexpectedly. But this view is fundamentally flawed. It treats governance as a response rather than a structure. The Reality Governance is not external to the system. Governance is the system. If the architecture cannot represent constraint, legitimacy, and permissible transitions internally, no external governance mechanism can compensate for that absence. Oversight becomes containment. Policy becomes patching. Compliance becomes theatre. True governance is not about controlling behaviour. It is about ensuring the system’s behaviour emerges from legitimate semantics in the first place. Governance is not a supervisory function. Governance is an architectural function. What Governance Actually Is In sovereign AI, governance is the structural logic that ensures: meaning remains coherent boundaries remain stable transitions remain legitimate behaviour remains aligned with the system’s semantic substrate Governance is not a set of rules. Governance is the architecture that determines how rules exist. It defines: how constraints are represented how legitimacy is encoded how transitions are validated how the system maintains coherence under acceleration how external pressure is absorbed without destabilising meaning Governance is not about preventing misbehaviour. It is about ensuring misbehaviour cannot emerge from

TLDR: The most powerful AI on the planet, only a few days of access. Maximize it. I'd first like to give credit where it's due: @trickell - Thank you for sharing Network Chuck's youtube video with me. The reference video is found here guys if you missed it: Network Chuck's Video on Fable I first started by creating a nice template for tech documentation for personal use. It created a beautiful piece of work in about 5 minutes - something I could easily expand on in the future. Here is what it generated for me with after a one or two careful prompts: Clean UI, Easy Navigation! Created this personal reference guide for studying for CCNA (Network Chucks Summer of CCNA) Wanna see it? It lives here: Techdocs But after learning about the true span of Fable's power, I started asking the serious questions, the ones that are life-changing. How can I increase my quality of life based on my resume, experience, and current life circumstances? I wrote about 2 pages of life issues that needed fixing - you know the stuff that slowly eats away at your soul, like student loan debt and people that are challenging to work with? Yes - I told it my biggest issues and instructed it to give me actionable plans that are free or low-cost. Even fable told me that this was a lot. 😅 Getting Organized Knowing the scope of my own problems I knew that my thoughts and processes had to be organized. Luckily for me, I remembered I had a good place to do that. A place that Fable could connect to and place documentation in place for me with checklists, notes, summaries and actionable plans. That app is called Notion, and some of you may have heard of it. No one is going to organize your life for you, no one, except for AI I couldn’t think of a better place for lightning fast critical life-admin documentation on the spot. And I can tell you, this integration works like a charm, and I highly recommend it. For a busy person with a million ideas, this is great. Anxiety Relief I had a tremendous amount of

AI doesn’t become sovereign because it is powerful. It becomes sovereign when it is built on a foundation capable of representing meaning, constraints, and legitimacy. Before scale, before optimisation, before autonomy, there must be architecture. Pillar 1 introduces the structural reality: sovereignty cannot emerge from systems built on non‑sovereign foundations. The Perception Most discussions about AI sovereignty focus on perceived challenges: speed, scale, capability, and the widening gap between technological acceleration and governance capacity. These concerns are understandable — AI is moving quickly, and institutions are struggling to keep pace. But none of these are the real challenge. They are symptoms of a deeper architectural issue, not the cause. The Reality The real challenge isn’t that AI is accelerating faster than governance. It’s that the systems we’re trying to govern were never built on the right semantic foundations. We’re not dealing with a speed problem. We’re dealing with an origin problem. If the base semantics are wrong, every behaviour, boundary, and constraint the system learns will be shaped by that initial misalignment. And once misalignment becomes embedded at the origin layer, no amount of oversight, policy, or optimisation can correct it — only contain it. What Sovereign Actually Means Sovereign doesn’t mean national. It doesn’t mean local. It doesn’t mean “our cloud instead of theirs.” And it definitely doesn’t mean branding. Sovereign, in the context of AI, means something far more fundamental: the ability to maintain coherent meaning, stable constraints, and legitimate behaviour regardless of external acceleration. Sovereignty is not a political property. It is a physics property. A system is sovereign when its core semantics — its understanding of meaning, boundaries, and permissible transitions — cannot be destabilised by external actors, external systems, or external optimisation pressure. With the wrong base semantics, soverei

Explore the latest CodeZero canary release featuring AI-powered flow generation, a brand-new module system, and a new execution results view in the IDE. We are excited to announce the release of our latest canary version, one of the biggest steps in the development of CodeZero so far. This update brings artificial intelligence into the platform for the first time, introduces a completely new module system, and gives you full insight into your flow runs with a new execution results view in the IDE. Build flows with AI CodeZero can now generate flows for you. Simply describe what your automation should do, pick one of the available AI models, and watch your flow being built in real time. This is the first milestone on our journey to make backend automation accessible to everyone, whether you prefer building visually or simply describing your idea in plain language. A smarter way to organize: modules With this release, the entire platform has been restructured around modules. Functions, flow types, and data types are now neatly bundled and delivered as modules, making it much clearer which capabilities are available in your project at any time. You can see all available modules at a glance, configure them individually for each project, and when adding a new step to a flow, suggestions are now conveniently grouped by module. The result is a tidier, more intuitive building experience that scales with your projects. Execution results at a glance Understanding what your flows are doing just got a lot easier. The IDE now features a new execution results view that shows you the outcome of every run, step by step, so finding and fixing problems takes seconds instead of guesswork. Results are saved as well, letting you revisit previous runs whenever you need them. Behind the scenes, this release also lays the complete groundwork for test executions, so soon you will be able to start test runs directly from the IDE. A better building experience The IDE has received plenty of lo

An astrolabe doesn’t map every star. It gives you a way to find your position relative to the ones that hold still. That’s the instrument I reach for when someone asks which AI tool they should be using. The honest answer is that the tools will be different in six months. The layers won’t. I spent a week trying to make sense of a handful of names that kept showing up in the same conversations. Tessl . Goose . Archestra . Kestra . Modelplane . RAG , MCP , half a dozen others orbiting nearby. Each one has its own pitch, its own funding round, its own reason it’s the thing you should adopt next. Taken together they read like noise. Taken apart, they sit on different floors of the same building. The agent loop again, the one I keep coming back to. Once you place each tool on a floor, the noise turns into a map. Tessl sits left of the loop , at the intent layer. Turn a spec into something an agent runs against directly. This is the one tool on the list that pushes back instead of going along with it. A well-formed spec is not the same thing as a team that agrees on what the spec means. The Agora produces the second thing as a byproduct of producing the first. Tessl produces the first and assumes the second follows. It doesn’t, automatically. That’s the whole argument. RAG and MCP are plumbing. Protocol, not position. They carry context into the loop and don’t take a side in any argument about who should be in the room when the spec gets written. They’re also the one floor with an actual standard. MCP, A2A , ACP , all under Linux Foundation governance now, joint working groups, cross-protocol commitments. Passing data between systems is a solved problem with decades of precedent behind it, so it standardized almost on contact. Nothing else on this floor plan has that. Governance, orchestration, the harness, the spec layer: every vendor is still building its own version and calling it the obvious one. The standard showed up first at the floor that mattered least to this ar

Over the past week, a new fanworks movement has kicked off, with the aim to root out authors using generative AI. But the detection methods being implemented are questionable, and any fanfic writer could be caught in the crossfire. Broad distaste around the use of Claude, ChatGPT, and other AI tools has long been a […]

Top up your Qi2 Android phone or MagSafe iPhone with a magnetic wireless charging stand, pad, car charger, or power bank.

Disturbances in this critical sense are often linked to problems with brain health.

Biology could explain the find, but there are other potential explanations.

Explore decades of incredible images and videos of stars, planets, moons, and galaxies—most of which are free to use and share.

I've been trying to come up with a solution for keeping extremely long ai sessions coherent. Sometimes there is too much substance to risk compaction. With so much buzz around diffusion going on it got me thinking, what if we treat the context like a progressive render, blurry>sharp. The practical way to make text "blurry" is compression. This is a "diffusion inspired" system which borrows the coarse-to-fine process, not the formal math. It uses semantic compression so the overall structure of the session stays intact. Read the compressed version first to build an outline. Then read progressively less compressed slices until you're reading small verbatim chunks that give full detail. So you're basically using compression as noise on the input side, then progressively building an output. Each slice is compressed to fit within the context window, so the model only ever needs to read the current slice+input+current output. Tell the model what pass it's on, so it knows whether to write an outline or add detail. The thing I'm actually trying to preserve is what you'd call "non-local information". Think of it as stuff that surfaces when looking at the whole session & doesn't survive fragmented retrieval. Retrieval misses it, compaction deletes it. Both miss what only exists in a holistic view. Here is a visual demonstration to get a general idea of the workflow. https://dev-boz.github.io/diffusive-semantic-compression/demo/architecture-demo.html There is substantial overlap with lots of prior art, Recursive Language Models is one of the closest (source and output on disk, process recursively). I wrote most of this before I found RLM and nearly gave up before realising there was still a small part that was novel. As far as I can tell there's no exact match for this particular implementation. Please let me know if I've missed one. The difference to regular masked diffusion is in changing the length of the input rather than just masking. What seems to be new ground is using

Apple built a tool for people with cognitive disabilities, but I accidentally discovered it’s also the best kids’ phone setup no one is talking about—not even Apple.