I contacted Nabisco. They say it's a combination of salt, oil, and crumbs and it happens. They said there's no peanut butter processed in facilities that make regular Ritz.
Search
1000 results for “just_tired”
-
It seems I need to go to the store for cheese. If I don't have it after the dog's dinners, they'll say they have to go out every 10 minutes, until they receive their cheese..
#dogs -
Don't buy Ritz crackers if there are peanut allergies. Mine were contaminated with peanut butter. Please share for those with peanut allergies
#peanutallergy -
Too tired to code or fiddle with emacs. Earlier I was just too tired to fiddle with Emacs and worked with PHPStorm. I probably should just uninstall PHPStorm and eat that frog already. So instead of doing any of that, I am researching what would be the best daily driver hardware (laptop) to run netbsd on…
Doesn't make a lot of sense either - not that I'd have money for an old ThinkPad anyway. I'll probably run my MacBook Air M1 with MacOs as long as this is possible and I'll think about switching operating systems then - support will be better by then, too.
-
Are you tired of AI agents that fake tests just to make the build pass? I built NewGod to solve this. Here is the story of how the factory caught its own bug and updated a game without breaking the database. 🛠️#agents #ai #buildinpublic #testing #software #coding #development #engineering #inclusive #community
Are you tired of AI agents that fake tests just to make the build pass? I built NewGod to solve this. Here is the story of how the factory caught its own bug and updated a game without breaking the database. 🛠️ -
A Sneaky Phish Just Grabbed my Mailchimp Mailing List
https://www.troyhunt.com/a-sneaky-phish-just-grabbed-my-mailchimp-mailing-list/
> You know when you're really jet lagged and really tired and the cogs in your head are just moving that little bit too slow? That's me right now, and the penny has just dropped that a Mailchimp phish has grabbed my credentials, logged into my account and exported the mailing list for this blog.
NOTE: The article is from March 2025.
-
I'm so tired of living through this. Everything I can do has been made pointless, and I don't know how to handle that.
I've mentioned before that a couple years ago I tried to push through denial and depression to acceptance by deleting my entire collection of projects, but that just ended up making me more depressed.
I miss living in a world where I had something meaningful to do.
-
#PhantastikPrompts 10/25: What is the maximum number of characters you have in a scene? Is there a limit for you?
I've mentioned this before, but it's wherever my heart takes me. However, normally, I do like keeping my scenes between 2000-4000 words. This isn't always the case, of course, because longer scenes require much more, but I try not to ever write less. The lowest word count I'll include might be around 1800 words. Random, maybe, but that's just how my brain works.
Edit: I'm tired and didn't even think of our story's characters. My mind instantly landed on character-limit, as in words.
Let's add this: It depends on the scene, as far as characters are concerned. I won't add more characters than I can feasibly handle writing, of course. You don't want to overcomplicate things or confuse the readers. That's a good judge of things, I think.
-
👋 Hey DEV Community!
Have you ever tried setting up a WhatsApp CRM for your startup, agency, or side project?If you have, you’ve probably hit the grim reality of the current WhatsApp SaaS ecosystem:
- 💸 Insane Seat-Based Pricing: Paying $50 to $150 per agent per month just to let a couple of teammates share one phone number.
- 🔒 Aggressive Vendor Lock-In: Your customer conversations, contacts, and custom fields trapped inside closed proprietary databases.
- 🤖 Restricted AI Gating: Rigid chatbots with heavy markups on tokens and zero ability to choose your own LLM.
- 🏋️ Bloated Self-Hosted Alternatives: Requiring a bulky 2GB+ RAM multi-container stack just to spin up basic webhook handlers.
I got tired of these artificial barriers. So I decided to build OpenWAB — a lightweight, 100% self-hostable WhatsApp CRM powered by a Universal Multi-Provider AI Engine.
And the best part? Zero software subscription fees. Zero seat pricing. No middlemen. You only pay Meta’s raw API charges directly to Meta.
I’m preparing to launch OpenWAB as a premier open-source project, and I’m looking for passionate developers, UI/UX designers, and open-source contributors to help build the future of WhatsApp automation! 🤝
⚡ What is OpenWAB?
OpenWAB is a production-grade, self-hosted WhatsApp CRM designed from day one to run on ultra-affordable infrastructure (strictly engineered to run under a ~510 MB active RAM budget on a standard $5/month VPS).It connects directly to the official Meta WhatsApp Cloud API, avoiding unofficial web scrapers, QR code hacks, and risk-prone reverse-engineered protocols.
+----------------------------------------------------------------------------+
| OpenWAB Flow |
+----------------------------------------------------------------------------+
| |
| 📱 WhatsApp Customer |
| │ |
| ▼ (Webhook < 50ms) |
| ⚡ Next.js 16 Webhook Ingestion ────► 🔒 HMAC SHA-256 Signature Guard |
| │ |
| ▼ (BullMQ Queues + Redis) |
| 📦 Message Worker ──────────────► 🐘 PostgreSQL + Drizzle ORM |
| │ │ |
| ├─────────────────────────┐ ▼ |
| ▼ ▼ 📡 SSE Real-Time Broker |
| 🤖 Universal AI Worker 📥 Media Download │ |
| (OpenAI/Anthropic/ (Encrypted Temp) ▼ |
| Gemini/Groq/Ollama) 💻 Shared Agent Inbox |
| |
+----------------------------------------------------------------------------+🔥 Features Built & Running Today
Here is what's already built, tested, and running under the hood:1. 💬 Real-Time Shared Agent Inbox
- Multi-Agent Collaboration: Your entire support or sales team can work together on a single official WhatsApp Business number.
- Server-Sent Events (SSE) Streaming: Ultra-lean, zero-polling live updates powered by an in-memory Pub/Sub broker — no heavy WebSocket server needed.
- Human-in-the-Loop Takeover: Instant toggle allows agents to pause AI auto-replies on the fly and resume manual customer conversations with zero latency.
- Threaded Quoted Replies: Send outbound messages quoting specific customer messages natively.
2. 🧠 Universal Multi-Provider AI Engine (BYOK)
- Bring Your Own Key (BYOK): Plug in your own API keys for OpenAI, Anthropic Claude, Google Gemini, Groq, OpenRouter, Mistral, Ollama, and DeepSeek.
- Reasoning Token Suppression: Strips internal Chain-of-Thought (
<think>...</think>) reasoning tokens so customers never see messy internal model thoughts. - Sliding-Window Burst Debouncing: When a customer sends 3–4 rapid-fire messages ("Hi", "I have a question", "Are you available?"), OpenWAB pauses for 4 seconds, combines them into one context payload, and generates a single thoughtful reply.
- Dynamic Failover: If your primary model hits rate limits or service hiccups, it seamlessly falls back to your configured secondary model.
3. 🛡️ Military-Grade Security & Vault Architecture
- Hardware-Grade AES-256-GCM Vault: Meta access tokens, App secrets, and AI provider keys are encrypted at rest with authenticated encryption.
- Webhook HMAC-SHA256 Verification: Pre-deserialization HMAC verification defends against DoS and memory exhaustion attacks.
- Zero Client Leaks: Encrypted secrets never touch the browser bundle or client-side telemetry.
4. ⚙️ Robust WhatsApp Cloud API Engineering
- Monotonic Message Status Ladder: Prevents out-of-order webhook deliveries (
readarriving beforedelivered) from regressing message checkmarks backwards. - 24-Hour Messaging Window Guard: Warns agents when Meta's 24-hour customer care window has elapsed, prompting pre-approved template messages.
- Asynchronous Media Mirroring: Inbound photos, voice notes, documents, and videos are automatically downloaded into encrypted storage before Meta’s short-lived CDN URLs expire.
- Interactive Messages: Built-in validator for WhatsApp reply buttons (1–3 buttons) and interactive list menus.
5. 🗃️ Lightweight Data Layer
- Drizzle ORM + PostgreSQL: Blazing-fast, type-safe queries with minimal memory overhead compared to heavier ORMs.
- Better-Auth: Secure, session-based authentication with role-based access.
- BullMQ & Redis: Distributed background workers (
message,ai,media,broadcast,outbound) ensuring zero dropped webhooks during traffic spikes.
🛠️ The Tech Stack
LayerTechnologyFrameworkNext.js 16 (App Router + Turbopack Standalone)LanguageTypeScript (Strict mode)StylingVanilla CSS / Modern Tailwind CSS v4 & Radix PrimitivesDatabasePostgreSQL + Drizzle ORMQueuing & CacheRedis + BullMQAuthenticationBetter-AuthRealtimeHTTP/2 Server-Sent Events (SSE) BrokerAI IntegrationUniversal Streaming Client (Multi-Provider BYOK)
We intentionally selected a modern, developer-friendly, and lightweight stack:🗺️ What We're Building Next (Roadmap)
This is where YOU come in! Here are the big features on our upcoming development roadmap:- [ ] 🤖 Model Context Protocol (MCP) Server: Allow external AI agents (like Claude Desktop, Cursor, and Antigravity) to query contacts and trigger messages via standard MCP tools.
- [ ] 📊 Kanban Sales Deals Pipeline: Drag-and-drop sales pipeline stages directly linked to WhatsApp chat threads.
- [ ] 🏢 Multi-WABA & Multi-Phone Support: Route multiple WhatsApp phone numbers across multiple internal workspaces.
- [ ] 🔑 Scoped Public REST API (
/api/v1): Secure API keys with fine-grained permissions for external webhooks, Zapier, and n8n integrations. - [ ] 🦾 And Much more features.
💡 Why Contribute?
By contributing to OpenWAB, you will:- Work with modern tech: Production Next.js 16, BullMQ concurrency, Drizzle ORM, and high-performance AI streaming.
- Solve real-world distributed challenges: Webhook deduplication, HMAC cryptography, sliding-window debouncing, and monotonic state machines.
- Shape an open-source alternative: Help break the monopoly of expensive SaaS WhatsApp platforms and empower indie hackers, small businesses, and agencies worldwide.
🙋 How to Get Involved
Whether you are a frontend wizard, a backend specialist, a DevOps enthusiast, or a technical writer, we would love your help!We're looking for contributors in:
- Frontend / UI: Refining the message composer, chat bubbles, audio player waveforms, and responsive mobile views.
- Automations: Building the React Flow canvas for visual automations.
- DevOps: Creating 1-click deploy templates for Docker Compose, Coolify, Railway, and Dokploy.
- Integrations: Adding connectors for Shopify, WooCommerce, Supabase, and Webhooks.
💬 Let's Discuss in the Comments!
- What is the #1 feature you miss in existing WhatsApp CRMs?
- What AI model would you use for automated customer replies?
- Are you interested in contributing to the upcoming open-source release?
Drop a comment below, leave your feedback, or share what you'd like to see added. Let’s build something incredible together! 🚀🔥
Note : I have vibe coded this whole project cuz i am a lazy developer but i have checked code for any tweaks and fixes, surprisingly AI wrote code more efficiently and optimal. So basically for further development i need other developers support and contribution to make this platform more effective.
#opensource #webdev #nextjs #ai #software #coding #development #engineering #inclusive #community
🚀 I Built a Self-Hosted, Low-Memory WhatsApp CRM with Universal AI (And I’m Looking for Contributors!) -
Your Python code works. It’s also slower than it needs to be. 🐢
If you work in AI or data, you’ve probably lived this loop:
Prototype in Python because it’s fast to write.
Hit a performance wall.
Rewrite the hot paths in C++, Rust, or CUDA.
Now you maintain two languages, two toolchains, and a fragile bridge between them.This is often called the two-language problem. It costs teams time, hiring flexibility, and a lot of debugging hours. Mojo is an attempt to fix it at the root.
What is Mojo?
Mojo was created by Modular, co-founded by Chris Lattner, who also created Swift and LLVM. It combines Python-like syntax with systems-level performance and memory safety ideas inspired by Rust, and it uses the MLIR compiler framework to target hardware such as GPUs, CPUs, TPUs, and ASICs.
opensourceforuThe goal is simple: one language from prototype to production, with code that looks familiar to Python developers.
Why 1.0 matters
For years, Mojo was a fast-moving experiment, and its syntax changed often. That made it hard to bet a real project on it.
Version 1.0 brings backward compatibility and API stability, and future 1.x releases are expected to be mostly additive. Modular also says it relies on Mojo daily in production, as the foundation of its own commercial products, MAX and Modular Cloud.
opensourceforu
modularIn short, the language you learn today shouldn’t break under you next month.
What problems does it solve?
- Performance without leaving the Python mindset
You write code that reads like Python, but you get control over types, memory, and hardware when you need it. You don’t have to jump to a different language for the hot path.
- One language for the whole stack
Instead of Python for the model and C++ or CUDA for the kernels, you can aim to write both in the same language. That means a smaller skill gap inside your team.
- Hardware portability
AI workloads now run on many kinds of accelerators. Because Mojo is built on MLIR, it is designed to target different hardware without rewriting everything per vendor.
- Gradual adoption
You don’t need to migrate your whole codebase. Mojo is designed to work alongside Python, so you can start with the one function that’s too slow.
A first look at the code
Here is a simple example. It looks like Python, which is the point:
mojo
def main():
var total = 0
for i in range(1_000_000):
total += i
print(total)The real gains show up when you add static types and use Mojo’s low-level features for performance-critical sections. Check the official Mojo docs for the current syntax, since the language was cleaned up significantly for 1.0.
Where to be realistic
I don’t want this to read like hype, so here are the caveats:
The ecosystem is young. Python has decades of libraries. Mojo does not, and you’ll often lean on Python interop.
It’s strongest for AI and performance-heavy work. For a typical CRUD web app, Python or Go is still the simpler choice.
Governance is worth watching. Modular was acquired by Qualcomm in mid-2026, and open-source status and community direction are things to keep an eye on as the ecosystem grows.
opensourceforu
Features are still arriving. Async programming, pattern matching, and tagged unions are on the roadmap.
opensourceforuShould you try it?
My take:
Yes, if you work on ML, GPU kernels, or numerical code and you’re tired of maintaining a Python and C++ split.
Maybe later, if your workload is mostly I/O-bound or web-focused.
Worth a weekend, if you just want to see where language design is heading.
Getting started
Read the official Mojo documentation.
Install the toolchain and run a small benchmark of your own slow Python function.
Port just that one function and measure the difference.Measure on your own workload. Benchmarks from other people’s projects won’t tell you whether it helps yours.
Final thoughts
The two-language problem has been accepted as “just how things are” for a long time. Mojo 1.0 doesn’t magically end it, but it’s the first time the idea feels stable enough to try seriously.
Have you tried Mojo, Rust, Zig, or another newer language? What problem did it solve for you, or why are you still skeptical? Let me know in the comments. 👇#programming #mojo #ai #python #software #coding #development #engineering #inclusive #community
Mojo 1.0 Is Here: Is the Two-Language Problem Finally Over? -
FOX Sports’ Ralph Vacchiano believes Jaylen Warren can carry the Steelers to the playoffs: “Over the past five weeks, running back Jaylen Warren has emerged as one of the NFL’s best and most elusive backs, and he’s the main reason the Steelers still sit tied atop the bruising AFC North. After shaking off a slow start — he amassed just 89 rushing yards and 61 receiving yards over the first two weeks — Warren has been on a heater. And after adding 101 rushing yards and three catches for 36 yards on Sunday morning in Paris against the New Orleans Saints, he’s now averaging 94.4 rushing yards and 141 total yards over the past five games. In short, Warren is giving the Steelers the power and the explosiveness they desperately need. Warren is the reason Rodgers’ last ride has a chance to finish with the 14th playoff berth of his Hall of Fame career.” #Steelers #NFL
-
Artcraft, Mindscaper, et al: Can we really just vibecode creative software?
Over the past couple days, massive hype has built up around Artcraft, a collection of literal clones of Adobe’s CC, Microsoft Office and other apps, entirely vibecoded and open source. Artists and creative folks battered by subscriptions costing hundreds and thousands of dollars a year finally smell relief that’s not the poorly designed open source jank of yesteryear, and the project receives dozens of similarly vibecoded pull requests each hour. At the same time, I’ve been building Mindscaper, practically with the same goal, but without the hype. As such, I have some thoughts and bias on this subject. And probably typos, this is 100% human-written.
Background
Artcraft is developed by Learning Machines LLC, which appears to be a one-man company by Brandon Thomas. Thomas previously developed the deepfake services “vo.codes” and “fakeyou.com” under this company, and developed VTubing tech. Judging by the blurb on “the.storyteller.company”, he appears to believe in “controllable AI” trivializing (“democratizing”) art creation, but with Artcraft opted to primarily clone existing professional software, putting AI on the backburner (although an AI subscription service is available).
By a lucky coincidence, I founded my company Koytek Wattenberg Media at a similar point in time, with similarly limited success. One of my biggest clients became Audacity, at which I worked on “democratizing” audio creation, and wouldn’t you know I’m also into VTubers. I started my hooray into vibecoding about half a year after Artcraft, focusing on Audacity-shaped audio and video editors, Soundscaper and Framescaper.
On technical matters
I have nothing new to say here that hasn’t been already said a billion times. Modern coding robots (I used Opus 5 and GPT 5.6 Sol mostly) are perfectly capable of making something that Just Works. They just happen to be lying, lazy bastards that will happily claim something exists when it doesn’t. Test-driven development principles keep them reasonably honest, though they occasionally do manage to find a way to write tests so unspecific that a pixel-by-pixel spectrogram in the Roseus color scheme and a spectrogram with much coarser buckets using a blue-to-yellow color scheme pass the same test.
I am under no illusion that the code they’ve produced isn’t ugly and suboptimal. But then, the Audacity codebase is 25 years old and also extremely ugly and suboptimal. The Audacity team – all extremely talented software engineers and beautiful people – have been unable to make Audacity 4 feature-equivalent to Audacity 3 in over a year, despite that “only” being a UI migration with some UX changes attached. With Soundscaper, I managed to get an app going featuring all of Audacity 3’s and 4’s features within 3 months, plus a plethora of additional DAW features and video editor on top of it. Similarly, Artcraft managed to get a Photoshop (and general Adobe CC) clone going in half a year.
On practical matters
While the robots are perhaps good enough to get functionality implemented, they suck at figuring out the finer details – and pretty much all of the design.
Robots suck at progressive disclosure
Progressive disclosure is the part of UX where, instead of showing everything at once, you show things as they’re needed. A trivial example for this would be a menu; the “Format” menu is reduced to that single word on your screen until you, the user, decide that now is the time to format something and click on it, revealing a dozen or so options.
Robots suck at this. If you tell them to add a feature, they’ll generally attempt to place it on screen with a dedicated button. This is fine for an app with 6 controls in total, but less so for a complex creation app with 500. Forcing them to chuck everything into menus and dialogs helps, but then we’re straight back into design paradigms from the 80s.
This is where Artcraft and Mindscaper both have an advantage over a pure vibecoded approach: Artcraft already knows where everything goes because they’re busy copying existing design. I know where my stuff goes because I am the designer, and thus have a very strong idea on what these features are, how they should work, where they should go and when they should show up.
Robots suck at information density
In a similar vein to the thing above, robots love to implement stuff as “Control title – control – explanation sentence”. Again, this is fine for a small dialog with 2 controls in it, but for any sufficiently complex effect it just either overwhelms people with too many words and/or requires things to be spaced so far apart to fit all this extra text that the dialog becomes massive.
And again, cloning existing dialogs works here, as does being the original designer to make relevant decisions. Purely vibecoding this from scratch is going to be much more difficult though.
Robots suck at asking the right questions
The biggest difference between working with humans and working with robots is what questions I’m being asked. With the Audacity team, I’d get asked about user edge cases as they popped up, I’d get asked about clarifications on my designs, I’d get asked about things by users. With the robots, there are a lot fewer of these kinds of questions; the only time the robot asks questions at all seems to be in plan mode. However, in plan mode, the questions that are being asked almost always are implementation-centric, ie the stuff I don’t really care about. So what ends up happening is that the robot will go ahead and do something, proudly proclaim it’s finished and then it’s up to me to QA whether it actually did the right stuff. And more often than not, it misses some design edge case.
On philosophical matters
In this section I’d want to talk about the should and shouldn’ts of vibecoding a creative software suite.
Copyright
Artcraft is copying various proprietary programs wholesale using AI. On Artcraft’s side, this has all the usual copyright questions attached (who is the author? is the code copyrightable?), though on Adobe’s side this becomes more interesting: From Tetris v. Xio, we know that the look and feel of a program (in that case, Tetris) can be copyrightable. Note that this is different from copyright on the code itself (which I don’t think Artcraft can even infringe given that their thing is in Rust, which Adobe’s stuff probably isn’t), and also is different from attempting to claim copyright on the app’s structure or underlying ideas (that’s patent stuff, not copyright).
Artcraft thus may be in for a rude awakening should Adobe feel threatened by them. Adobe may or may not win this case, but they also probably don’t need to in order to hobble Artcraft’s development for years to come. Funnily enough, the actual code being open source may be a saving grace here, as it likely can trivially be forked, copied and modified to avoid Adobe’s gaze, to a better degree than pirates ever could. Another point in favor of Artcraft is AI itself; any rulings in favor of copyright holders over AI developers is also a ruling against Adobe’s own products. It thus may be that Adobe opts to do… nothing, in order to avoid the backblast. I don’t think they’ll necessarily care about the possibility of a Streisand; lawsuits like this generally are boring enough for the wider press to not care beyond perhaps a single story in the margins.
Mindscaper meanwhile doesn’t have that problem, as Soundscaper is building upon an open source app and crediting it, and Framescaper is original.
Patents
Software patents unfortunately arguably exist, some of them on UI (eg the Ribbon pattern found in MS Office). Adobe, unsurprisingly, has a tens of thousands of patents.
Software patents are one level more devious than mere copyright: It doesn’t matter that you had the idea all on your own, or that the idea may be obvious now, all that matters is that someone else also had the idea before you. And if they have registered it, you now are in trouble. It’s because of software patents that loading screens don’t have minigames, it’s because of software patents that Audacity makes you jump through hoops to download FFmpeg, as there are still over 3000 patents in the AAC patent pool alone. And if just a singular patent survives litigation, which given the sheer number of patents involved is gonna take forever anyway, you’re on the hook for yet more damages.
Software patents are the ideal tool for corporations to shut down people you don’t like, hence why some corporations (including Adobe and Microsoft, the companies most likely to be upset by what Artcraft is doing here) engage in non-aggression pacts with each other, like the Allied Security Trust or Open Innovation Network – this prevents these companies being at each other’s throats for patent reasons all the time.
However, these defensive alliances generally don’t apply to people outside the alliance, and neither Artcraft nor Mindscaper are in one. Thus, whenever one of the incumbents ends up being upset or feel threatened by what’s happening, they can pull the litigation lever.
I don’t know which patents could be relevant here, and frankly, I also don’t wanna know – in the end it doesn’t really matter. Patents are a risk factor for any software, and typically best left ignored as patent holders tend to be more busy with actual business than going after one-man companies. However, when you sufficiently piss off a company – and I’d argue that wholesale cloning of a software might constitute that – you have a lot stacked against you.
Freeing users
Subscription services for software create incentives for the builder of the software to put as little work as possible into the software while charging as much as possible. This allows the Autodesks and Adobes of the world to charge ridiculous amounts, while providing software so bad that it regularly attracts user petitions, begging them to fix longstanding bugs degrading the experience.
Simply providing free software alternatives here may work (eg in the case of blender and musescore), or may not work, as free software does (or at least: used to) suffer from small development teams and quite frequently UX so weird that it wasn’t possible for some folks to figure out how to use the program in question. A famous example for this is the “make a circle in GIMP”. The solution is to make an elliptical selection, intuit that you can convert that to a path, and then use a panel to draw the path – as opposed to Photoshop, where you just use the circle tool.
Providing free software versions of a program would indeed free people of subscription software to use something else, depending on the copyright situation more or less easy compared to pirating, and this is what Artcraft does provide.
Freeing new users
However, I’ve found that the entire creative software field suffers from underdeveloped design. A lot of professional-grade software is modeled after pre-digital hardware and uses design metaphors that simply don’t make sense if you haven’t experienced said hardware. I remember when Lightworks, an Oscar-winning video editor, became a free download in 2010, I couldn’t for the life of me figure it out, not even typically simple things like rendering the video. This is despite me having had some experience in Sony Movie Maker (the cheap version of Vegas) and Powerdirector.
This is understandable somewhat: To attract professional users in the 80s and 90s, you’d need to replicate their workflows from their pre-digital tools. And once you have these users and they’ve learned how to use the program, they’d hate to have to adapt to a new design. However, this also leads to new users having to jump through enormous quantities of hoops trying to learn the program. If you want to “democratize” art creation, making things free and open source is one thing, but the barrier to entry of learning the tool remains the same.
This is where my work on Audacity (and now Soundscaper) becomes relevant: It takes quite a bit of design work, but it in principle should be possible to design a complex creation app in such a way to make it easy to use. Notably, not everything has to be equally easy – setting up a simple recording should be a one-button operation, while setting up a more complex multi-track recording may be a bit more involved, as we can expect the user to have a more clear task in mind on which input goes to which track.
Our vision for Audacity (and Musescore for that matter) was to completely starve the current incumbents of new users by just having a much more modern design and having an app that’s easier to get into. I still think this is the way things will shake out eventually; we’ve already seen Finale starve to death from this pressure.
Artists
Of course, AI bros would go further here and envision a future where skill is completely replaced by AI. And while for things that already were sloppy and primarily utilitarian to begin with (shitposts, local business signage, anything using Wordart/clipart in the past), AI certainly is going to replace more dedicated tools, I don’t see it doing so for artists. To draw a chess analogy, computers have been better than humans in chess for a long time, yet humans still play chess, for one simple reason: It’s fun. Similarly, artists don’t really care if a robot can do a hyperrealistic godzilla in mere seconds, as the fun part of making art is actually creating it, not just admiring the result (that would be mere consumption).
As an artist, you of course get to pick your battles. You can decide that shading or coloring is too annoying, and stick to strict black and white, or that mixing and mastering is too annoying and stick to making melodies and chords. From there you can hire someone to do the shading and coloring and additional work for you, or indeed use AI instead. In either case, your initial creative vision gets diluted by the other work; the more people are involved and the heavier the AI use, the more diluted your vision gets. This can be acceptable to you, especially in a world where art is traded as a commercial good, but if we assume that art as a good is going to lose worth, this tradeoff may become less worthwhile, perhaps making it so that you only wants tools strictly designed for you to express yourself.
For-profit open source
Having both worked at and seen for-profit open source, I’m perhaps a bit jaded:
- We see companies close access to their source the moment they feel like they can extract revenue out of it (various server software comes to mind)
- We see companies increase the amount of closed components in open source software, to guarantee only they can have a revenue stream (VSCode and Android come to mind)
- We see companies add user-hostile features to benefit only themselves (Google Chrome/Android is the poster-child here, to the point where regulators need to step in to it)
There might be a way to make a for-profit company be a good steward of an open source project, but the incentives always point in a different direction – and even if the current leadership can resist these incentives, the next one can flip towards enshittification so fast. I haven’t seen Thomas’ Artcraft project enough yet to know whether he’ll stay true to open source, though given he already has a subscription service (for cloud AI compute, of course) and a launcher ready, I gotta say that I’m worried.
It’s for this reason that I spun out Soundscaper from my company kw.media into Mindscaper, a non-profit association. It is now immune to me, or anyone else for that matter, deciding I would like it to make me tons of money, as long as its members (so, ideally, the users) don’t want to be milked. As an association (as opposed to a foundation), it also is way more democratic, giving users a real voice in what should happen to Soundscaper.
Resources & Sustainability
It’s impossible to discuss AI without touching upon the massive resource use it causes. Throughout my time developing Soundscaper, I have burnt through Codex’ and Claude’s 20x subscription quota almost every single reset cycle, including OpenAI’s ridiculous practice of vibing when a reset occurs and having a dude announce it on twitter. This has cost me hundreds of dollars, would have cost me tens of thousands of dollars in API cost, and has cost OpenAI and Anthropic likely thousands of dollars as well.
It is clear to me that the current pricing isn’t sustainable, and that slowly but surely, costs will go up. It is for this reason that Soundscaper uses local inference whenever useful and won’t be integrating with any cloud AI services. As far as I’m concerned, the entire point of open source is to fuck around with stuff on the machines you have access to and have it not tied to some service which decides what is and isn’t allowed.
It also is clear to me that there are real environmental impacts vibecoding this hard has; especially when comparing how long and hard my local setup has to work to achieve much simpler tasks (I let gemma and aya-expanse handle translation work locally, for example). Thus, I try to limit my vibecoding to the areas I really care about. I have a media background, so I shall vibecode media tools I’ll personally use – as opposed to token-maxxing just because I can.
Conclusion
So, can we vibecode creative software? On a technical level, yes. On a design level, yes, if we are a designer or follow someone else’s design. But should we? Depending on how adventurous we are with copyright and patent laws, especially if we are just re-implementing someone else’s design – maybe not.
We absolutely should open source and reverse engineer the things we care about, but we shouldn’t take a robot’s “one-shot” in an area we know nothing about as proof that it’s good now. It’s enormously easy to slop a whole software suite into existence but it actually takes some real work to get the software suite to actually be usable by real people – and surely, the benefit to real people has to be the goal.
If you’re interested in contributing to a non-profit making creative software, consider joining Mindscaper.
#ai #artcraft #artificialIntelligence #audacity #mindscaper #openSource #software #soundscaper #technology #vibecoding #writing -
DATE: October 25, 2026 at 08:00AM
SOURCE: PSYPOST.ORG** Research quality varies widely from fantastic to small exploratory studies. Please check research methods when conclusions are very important to you. **
-------------------------------------------------TITLE: Neuroscientists are digging into a worrying link between polluted air and children’s brain wiring
Different sources of fine particle air pollution show distinct, subtle links to how the developing brains of children communicate, according to new nationwide research published in Journal of Environmental Psychology. Particles from traffic, coal burning, and agricultural fertilizers were each tied to their own patterns of connectivity in networks involved in sensory processing and higher-order thinking. The findings offer early evidence that where air pollution comes from may matter, not just how much of it children breathe.
Outdoor air pollution contains fine particulate matter, commonly known as PM2.5, which consists of airborne particles smaller than 2.5 micrometers across. Because these specks are tiny enough to inhale deep into the lungs and enter the bloodstream, they may reach the brain.
The brain coordinates its activities through large-scale functional networks, which are collections of brain regions in different locations whose activity tends to rise and fall together. Researchers can measure this synchrony with brain scans that track changes in blood flow while a person lies still and rests. During childhood and the transition into adolescence, these communication channels continue to reorganize as youth develop adult reasoning, sensory integration, and emotional control.
Past research has linked outdoor air pollution to differences in these communication patterns. In a 2023 longitudinal study, members of the team behind the new research used data from the Adolescent Brain Cognitive Development Study, a large national project following thousands of American youth. They found that children with higher exposure to fine particles and other pollutants showed differences in how their resting brain networks matured across early adolescence. Additionally, a study covered by PsyPost in 2023 found that briefly breathing diesel exhaust in a controlled experiment temporarily weakened connectivity within the default mode network, a set of regions most active during mind-wandering and self-reflection, in adults.
Fine particulate matter is not a single chemical substance, but rather a complex blend created by both natural processes and human activities. Addressing this complexity, a 2024 study by members of the same team, using data from the same national project, found that specific chemical ingredients and pollution sources had varying relationships with children’s memory and thinking skills. The new study uses the six pollution sources identified in that work. The investigation was led by Katherine L. Bottenhorn of the University of Southern California and Florida International University and Megan M. Herting of the University of Southern California.
For the new study, the authors again drew on data from the Adolescent Brain Cognitive Development Study, which spans 21 research sites across the country. Data from one site were dropped because of hardware problems, leaving 20 sites for the cross-sectional analysis; the longitudinal analysis was limited to the 12 sites that used the same brand of scanner. The researchers analyzed brain scans from 6,291 children who were between 9 and 11 years old, as well as a subset of 1,972 participants scanned on consistent magnetic resonance imaging equipment roughly two years later, between ages 11 and 13.
The participants’ resting-state brain activity was recorded while they relaxed with their eyes open. The scientists mapped interactions among 12 functional networks, encompassing primary sensory networks like vision and hearing, attention circuits, and higher-order systems. The salience network helps flag important events and shift attention, while the cingulo-opercular network, described here as a cognitive-control network, helps keep attention on a task.
The team used annual air quality models tied to each child’s home address to estimate their exposure to 15 chemical components of air pollution during 2016. By grouping these chemicals mathematically, the authors estimated exposure to six primary sources: crustal materials (such as soil and dust), ammonium sulfates (largely from coal combustion), biomass burning (such as wood smoke and wildfires), traffic emissions, ammonium nitrates (often linked to agricultural fertilizers), and industrial fuel combustion.
The researchers applied a machine learning method called connectome-based predictive modeling to identify connectivity patterns related to each pollution source. To see if the results could generalize across the country, the scientists trained models using participants from all study sites except one, and then tested how well that model predicted pollution levels for children living at the held-out site. The analyses adjusted for several potential confounding variables, including household income, race and ethnicity, perceived neighborhood safety, neighborhood population density, distance to major roads, urbanicity, physical activity, screen time, scanner hardware, and head movement inside the scanner.
The cross-sectional analysis at ages 9 to 11 identified consistent links between specific pollution sources and connectivity across sensory and motor networks. Greater exposure to traffic emissions related to weaker functional communication between visual and mouth-related motor networks, as well as between auditory and cognitive-control circuits. In contrast, higher exposure to ammonium sulfates was linked to stronger communication between sensory systems and higher-order cognitive networks, including the default mode network. Crustal materials, industrial fuel burning, and total particulate matter were each tied to a handful of sensory and attention-related connections, while biomass burning showed no consistent pattern at ages 9 to 11.
Higher-order networks, which are involved in introspective thought, stimulus processing, and, according to some researchers, vulnerability to mental health problems, were also tied to specific pollution sources. Exposure to ammonium nitrates was associated with stronger communication between salience and cognitive-control networks, but weaker communication within memory networks and between attention networks and other networks.
Over the following two years, the researchers found consistent patterns of change linked to three sources. Higher traffic exposure was tied to increasing connectivity over time between hand-movement networks and attention-related areas, but decreasing connectivity between auditory and cognitive-control networks. Higher biomass burning exposure was linked to increasing connectivity among attention-related networks, and higher ammonium sulfate exposure to weakening connectivity between an attention network and a hand-movement network, while crustal materials, ammonium nitrates, industrial fuel burning, and total particulate matter showed no consistent pattern of change.
Despite identifying consistent connections in the training data, the connectivity patterns accounted for less than 1 percent of the variation in children’s exposure at ages 9 to 11, and no more than about 2 percent for changes over time. When tested on children from held-out study sites, the models performed no better, and often worse, than simply guessing the average exposure. Prediction errors were largest at sites in the western United States and at sites where exposure levels varied more from child to child.
The authors concluded that, after accounting for other factors, these pollution sources likely play only a small role in differences in brain connectivity between children, and that the links may not apply to youth in other regions. They also note that the patterns for biomass burning and ammonium sulfates held up best across sites, while those for crustal materials and traffic emissions deserve more caution.
The findings are in line with a study covered by PsyPost earlier this year, which found that young teenagers exposed to elevated particulate pollution showed less brain network maturation over two years, though that previous research evaluated an overall brain maturity score rather than connectivity across specific functional networks and distinct pollution sources.
“This is an important and timely topic, and the paper complements a growing body of evidence that children’s physical environments in general, and air pollution exposure in particular, are associated with their neural and cognitive development,” said Monica Rosenberg, an associate professor of psychology at the University of Chicago, director of the Cognition, Attention, and Brain Lab, and a co-developer of the brain-modeling technique used in the study, who was not involved in the research.
“The longitudinal aspect of this work is unique and is a major strength—the authors didn’t just show associations between brain networks and pollution at a single time point but found that pollution predicts developmental trajectories of networks,” Rosenberg told PsyPost.
There are a few things to keep in mind when interpreting these findings. The study used observational data and statistical associations, meaning it cannot establish that breathing these specific particles directly caused the observed network differences. Because the research took place across many regions with varying environmental mixtures, local factors that were unmeasured might account for some of the geographic discrepancies.
The authors also did not apply a statistical correction for the many connections they tested at once, so some of the identified links could be false positives, and the analysis was exploratory, with no advance predictions about which networks would be affected. Because each study site used scanners from a single manufacturer, differences between regions cannot be fully separated from differences in scanning equipment.
Rosenberg noted that the geographic inconsistency represents an important caveat for understanding the results. “One caveat is that the primary predictive models did not successfully generalize across sites, meaning that associations between brain network patterns and air pollution were inconsistent across geographic locations,” she said. “In addition to the thorough analyses presented in the paper, it would be interesting to test whether the observed brain changes were associated with cognitive and/or attentional performance since the implications of neural changes alone aren’t always clear.”
Another caveat involves how exposure was measured. The researchers assigned air pollution levels based on each child’s home address during a single year, which does not capture personal daily habits such as indoor air filtration, ventilation, daily travel routes, or time spent exercising outdoors. In addition, the participants in this nationwide study were somewhat more likely to come from higher-income and non-Hispanic white households than the national average, and average particulate exposures across the sample were below current federal limits. Future studies will need to follow youth through later adolescence to evaluate whether these source-specific network patterns correspond with tangible differences in sensory function, attention, or mental health outcomes.
The study, “Sources of outdoor air pollution exposure and child brain network development across the United States,” was authored by Katherine L. Bottenhorn, Kirthana Sukumaran, Amanda C. Del Giacco, Hedyeh Ahmadi, Jordan D. Corbett, Alethea V. de Jesus, Carlos Cardenas-Iniguez, Rima Habre, Daniel A. Hackman, Joel Schwartz, Jiu-Chiuan Chen, and Megan M. Herting.
-------------------------------------------------
Private, vetted email list for mental health professionals: https://www.clinicians-exchange.org
Unofficial Psychology Today Xitter to toot feed at Psych Today Unofficial Bot @PTUnofficialBot
-------------------------------------------------
#psychology #counseling #socialwork #psychotherapy @psychotherapist @psychotherapists @psychology @socialpsych @socialwork @psychiatry #mentalhealth #psychiatry #healthcare #depression #psychotherapist #AirPollution #ChildrensHealth #BrainDevelopment #Neuroscience #ChildDevelopment #CleanAir #PM25 #EnvironmentalHealth #PublicHealth #ClimateAndHealth
-
Asocial
I came home from work some time ago to find my wife settling down to watch the latest episode of Coronation Street.
Onscreen, a new family had recently moved on to the street, and the Dad was shown talking to a couple of the regular characters, making arrangements to do something, and it struck me – in just 3 minutes of screen time, a brand new character had exchanged more words with his neighbours than I had in the 10 1/2 years I had lived here.
Which got me thinking – of all the things I know, how to make friends isn’t one.
Out of all my friends (at least, out in the so-called “real world”), all of them decided I was a person they wanted to be friends with, they did all the running, and all I did was decide to go along with them.
This was rarely something I did lightly – there were plenty of people who decided we were going to be friends, but I decided to have nothing to do with them – but with all the people I count as friends, they did all the running, and I just went along with it.
It’s the same with relationships – off hand, I can only think of 6 times I asked girls out – 2 of them turned me down flat, 2 were the same girl on 2 different occasions (and I eventually asked her to marry me – which later happened!), and the other 2 times ended pretty disastrously. Every other time I got into a relationship, they did all the running after me, and I just went along with it.
On a related note, I have no idea how small talk works – this is an essential skill for developing all manner of relationships, and yet I have not a single clue as to the purpose of small talk, nor how it works – I can do it, but only by copying conversational gambits I’ve seen other people use, which means that conversations with me can often be stilted, and are liable to turn rather strange at unexpected moments.
By extension, flirting (and “chatting someone up”) is also something where I utterly fail to grasp any mechanism by which it works. As I said about small talk, I can do it, I just have no idea what I’m doing.
Actually, I would like to modify those statements – I can do small talk and flirting, but only if I don’t think about it – as soon as I start to think about what I am doing, or what I should say next, I turn in to Cat in the infamous dance/dream sequence from Red Dwarf ( https://youtu.be/yn8wWQweNbU ) – I get tongue-tied, and completely unable to communicate.
Which, let’s face it, isn’t good, whether you’re discussing the weather with the random person sitting next to you on the bus home from work, or chatting up some random stranger in a bar.
I’ve no idea if it is connected to all this, but I have always had a preference for my own company – not having to fill any silences or think of topics of conversation is always pleasant.
I remember back in school, I had a friend I spent a lot of time with – many were the times we finished school, went to the local library to collect some books, then went back to his, where we would occupy chairs at opposite sides of his living room, then read books in silence, until the time I had to leave to go home – about the only thing his mother ever heard me say was “Right, I’d better get off. See ya!”
One of the things I love about my marriage, and my wife – we often spend time just being in the same room – not necessarily talking, not necessarily doing the same thing, but doing whatever it is we are doing, together.
One of us might be watching telly while the other reads, or she might be doing something on her computer, usually doing some family history research, and I’ll walk in with my laptop and slouch down in a chair and do some writing for one project or another – but we are doing it, together, just enjoying being with someone.
Louise’s office is by the front window of the dining room, and I will often be found in the kitchen, through the rear of the dining room, cooking up a storm, while we listen to some music, which usually involves one of us dancing our way over to the other and busting some moves for a few seconds before going back to what we were doing.
We might also be talking – but no-one is being forced to talk, only when we are ready, which I find makes conversations flow more easily.
And this is the thing – I’m not, as some people think, anti-social, I don’t hate people, I don’t want to avoid having friends – I just want friends who are on my wavelength, friendships on my terms – friends who are willing to accept that I don’t always want to be drawn into conversation, but when I feel the need to talk will accept that as well.
I’m asocial, quite possibly because of my autism, and proud of it.
Social interactions leave me physically and mentally exhausted – which means that, if I put any time or effort into interacting with you, then you should feel honoured.
(Or I’m at work, and have to put the minimum effort in!)
-
🦥 Nudgify: An AI-Powered Productivity Companion That Does the Remembering So You Can Do the Living | Hacktoberfest: Slow and Steady
What if your productivity app didn't just wait for you to remember things, but actually helped you stay on top of them?We all have those little tasks that seem insignificant until we forget them.
Reply to that message. Finish that assignment. Remember that deadline. Follow up with a friend. Prepare for tomorrow. Do that one thing you've been postponing for the past three days.
Individually, these tasks aren't particularly difficult. The problem is remembering all of them, keeping track of when they need to happen, and making sure nothing important slips through the cracks.
That's where Nudgify comes in.
For this Hacktoberfest challenge, Slow and Steady, I wanted to explore an idea that feels simple but has a surprisingly meaningful impact: building technology that takes repetitive mental work off our hands.
Nudgify is an AI-powered reminder and productivity assistant designed to help people manage their responsibilities, remember important tasks, and stay accountable without constantly having to organize everything themselves.
Because sometimes, the smartest thing technology can do is give us one less thing to worry about.
🦥 1. The Inspiration: Maybe We Don't Need to Work Harder
The theme of this week's challenge is inspired by International Sloth Day, and honestly, I think there's something worth learning from sloths.They don't rush around unnecessarily. They conserve energy and move at their own pace.
Meanwhile, we live in a world where everyone seems to be juggling ten different things simultaneously.
College assignments, project deadlines, internship applications, messages from friends, personal goals, and a never-ending list of things we promise ourselves we'll do later.
The funny part? Sometimes, we spend so much energy remembering what we need to do that we have less energy left to actually do it.
Think about a typical student.
You have an assignment due next week. A friend asks you to remind them about something tomorrow. You need to submit an application, prepare for an upcoming test, and finish a project you've been putting off.
You might write some of these things down. You might set a few alarms. You might even promise yourself that you'll remember everything.
And then, inevitably, something gets forgotten.
The problem isn't necessarily laziness. It's that our brains aren't designed to function as perfect notification systems.
What if we stopped expecting people to remember everything and started building software that helped them remember what matters?
That question became the starting point for Nudgify.
💡 2. What Is Nudgify?
Nudgify is an AI-powered productivity companion built around a straightforward idea:Let software handle the remembering, organizing, and nudging, so people can focus on doing.
Instead of treating reminders as isolated alarms, Nudgify explores a more helpful approach to everyday productivity.
The goal is to create an experience where tasks, deadlines, and accountability are easier to manage, whether you're trying to stay organized yourself or helping a friend stay on track.
Here are the core ideas behind the project.
⏰ Smarter reminders
A reminder should do more than simply exist somewhere in a list.It should help you bring your attention back to something at the right moment.
Nudgify is designed around making important tasks easier to track and revisit, reducing the need to repeatedly check your schedule or mentally calculate how much time remains before a deadline.
🧠 Less mental clutter
How many times have you opened your phone to check one thing and ended up scrolling for twenty minutes, only to forget what you originally intended to do?A productivity tool should reduce the number of things demanding your attention, not become another source of distraction.
Nudgify aims to keep important responsibilities visible without requiring users to constantly monitor them.
🤝 Accountability between friends
Productivity isn't always a solo activity.Sometimes, a little encouragement from someone else makes a difference. Friends can have shared goals, upcoming deadlines, or commitments they want help remembering.
Nudgify explores how an assistant can make this kind of accountability easier while keeping the experience centered on the people using it.
The objective isn't to turn friendships into project-management systems. It's to make helping each other a little easier.
🤖 AI as a practical assistant
AI is often presented through spectacular demonstrations: generating entire applications, answering complicated questions, or producing impressive pieces of content.But I think one of its most valuable applications is much more ordinary.
It can help make repetitive digital workflows feel less tedious.
Rather than using AI simply because it's fashionable, Nudgify is an exploration of how AI can support a genuinely useful everyday experience.
🔓 3. Why Open-Source AI?
This is the part of the challenge that interests me most.The Slow and Steady challenge isn't simply asking us to build an application with AI somewhere in the stack. It specifically encourages us to explore open-weight models, open-source AI frameworks, local inference, and other open technologies that meaningfully power our projects.
And there's a reason that distinction matters.
When developers build exclusively around a closed AI service, they can become dependent on a provider's available models, pricing structure, API limits, and infrastructure.
That can be perfectly reasonable for some projects. Hosted AI services are convenient and can be incredibly capable.
However, convenience shouldn't be the only option.
Open-source AI and open-weight models give developers more room to experiment with how AI is deployed, customized, and integrated into an application.
For a project like Nudgify, that flexibility creates several interesting possibilities.
🔓 A. Freedom to choose the model
Different AI models have different strengths.One might be better at following structured instructions. Another might be faster for simple tasks. A smaller model might be sufficient for extracting dates or classifying reminders, while a more capable model might be useful for complicated requests.
An open approach allows developers to evaluate alternatives instead of designing the entire product around one provider.
For example, a future version of Nudgify could use a lightweight model for straightforward reminder processing and reserve more capable models for tasks that genuinely require them.
The model becomes a component that can be evaluated and replaced, rather than a permanent limitation on the product's design.
🔐 B. Privacy should be part of the architecture
Think about the information a personal productivity assistant might handle.It could contain assignment deadlines, daily routines, personal commitments, private notes, and reminders involving other people.
This information may not look especially sensitive when considered individually, but together it can reveal a great deal about someone's life.
That raises an important question:
Does every AI-powered task really need to send personal information to an external server?
Not necessarily.
For tasks that can be handled by a sufficiently capable local model, local inference could allow processing to happen on the user's own device.
That would provide an opportunity to reduce external data transfers and give users more control over their information.
Local processing isn't automatically private in every respect, and the rest of the application still needs appropriate data-handling practices. However, reducing unnecessary transmission is a meaningful architectural advantage.
💻 C. AI that doesn't always depend on the internet
Imagine opening your productivity assistant while travelling, sitting somewhere with unreliable connectivity, or working away from your usual setup.If an appropriate model runs locally, certain AI features could remain available without an internet connection.
That would make the application less dependent on network availability for those particular tasks.
Of course, a fully offline experience requires more than downloading a model. Data storage, authentication, synchronization, and any external notification services must also be designed to support offline use.
Still, local inference makes offline AI a realistic design possibility rather than something that necessarily requires a remote API.
💸 D. Lower barriers to experimentation
Experimenting with AI can become expensive when every iteration depends on a metered API.You might want to test different prompts, compare models, change how an assistant behaves, or run repeated evaluations.
Open-weight models can make it possible to conduct some of this experimentation without paying a separate hosted-inference fee for every request.
That doesn't mean running AI is always free. Hardware, electricity, hosting, and infrastructure can all have costs, and some model licenses impose additional conditions.
But having the option to run models on hardware you already own can make experimentation more accessible.
For students and independent developers, that matters.
You shouldn't need a large budget just to explore an idea.
🛠️ E. The freedom to understand and change things
Perhaps the most important benefit is the freedom to learn by doing.When a model is open-weight and its license permits the intended use, developers can inspect its available artifacts, run inference, evaluate its behavior, and sometimes fine-tune it.
Open-source frameworks can also make it easier to understand and modify the surrounding application logic.
Instead of treating the AI component as a mysterious service, you can investigate how it works, compare alternatives, and build a system that suits your requirements.
For a student developer, that freedom is valuable in itself.
Open innovation isn't just about using something that is free. It's about having more control over what you can build with it.
🧩 4. Why This Approach Fits Nudgify
A reminder assistant might seem like a small application, but it presents some interesting design questions.Which tasks actually require AI?
Which can be handled with ordinary code?
When should the application notify the user? What information needs to be stored? What happens if a notification is delayed? How can the assistant remain helpful without becoming annoying?
These questions are just as important as the model itself.
For example, consider a reminder scheduled for tomorrow at 10 AM.
There is no reason to ask an AI model to continuously calculate the time until that reminder. A conventional scheduling system can handle that reliably.
AI might be useful when a user describes a task in natural language, needs help interpreting an ambiguous request, or wants to turn an unstructured instruction into a structured task.
A well-designed application can combine both approaches.
TaskAppropriate approachStore a reminderDatabase or structured storageCalculate time until a deadlineOrdinary application logicInterpret a natural-language taskAI, when usefulSchedule a notificationScheduling infrastructureGenerate a short task summaryAI, when usefulDeliver notifications while a tab is closedBrowser push infrastructure and a push-capable backend
This separation is important because AI shouldn't be used for everything simply because it is available.Reliable application logic should handle predictable operations, while AI should be reserved for tasks where flexible language understanding or generation adds genuine value.
That also creates a natural opportunity to use a smaller open-weight model for suitable AI operations without making every part of the application dependent on inference.
🏗️ 5. Building the Application: The Technology Behind Nudgify
Nudgify uses a modern web-development stack designed to support an interactive frontend, application logic, and AI integration.The current project stack includes the following technologies:
Frontend
React 19React provides the component-based foundation for the user interface. It allows the application to be organized into reusable components rather than a collection of disconnected screens.
Vite 8
Vite provides the development and build tooling for the frontend, helping keep the development workflow fast and straightforward.
TypeScript 7
TypeScript adds static typing to JavaScript, making it easier to define data structures and catch certain mistakes during development.
For an application that handles tasks, deadlines, and user interactions, clear data structures help keep the codebase maintainable.
Tailwind CSS v4
Tailwind CSS provides utility-based styling that makes it possible to develop and refine the interface without maintaining a huge collection of unrelated CSS rules.
The objective is to create an experience that feels like a practical product, rather than a technical demo assembled around an AI API.
Backend
Node.js and Express 4The backend provides the foundation for handling application requests and server-side workflows.
Keeping backend responsibilities separate from the frontend also provides room to evolve the application as its functionality grows.
AI integration
Google Gen AI SDKThe project includes the Google Gen AI SDK for AI integration.
This is an important distinction for the open-source AI challenge: a hosted AI SDK does not, by itself, make an application open-source-AI-powered.
To make open AI central to Nudgify, the model layer needs to incorporate a suitable open-weight model or an appropriate open-source AI component as a meaningful part of the actual application.
That could involve evaluating a locally hosted model, adding a compatible inference backend, or building a model adapter that makes switching between supported models straightforward.
The goal is not to add an open model just to satisfy a checklist. It is to use the model where it provides real value.
Data storage
Browser localStorageThe project uses browser localStorage for supported client-side data.
This can be useful for lightweight persistence, but it is important to understand its limitations: browser storage is tied to a particular browser and origin, isn't automatically synchronized between devices, and shouldn't be treated as a secure database for sensitive information.
A more complete multi-user application may require server-side persistence, appropriate access controls, and a clear strategy for data synchronization.
Each part of the stack has a purpose, and understanding those boundaries is part of building a product that can grow beyond its initial prototype.
🔔 6. Notifications: A Reminder Is Only Useful If It Reaches You
There's another practical challenge with reminder applications.Imagine creating a reminder, closing the browser tab, and assuming the application will notify you when the time comes.
If the application only checks for reminders while its page is open, that assumption may not hold.
This is why notification delivery deserves its own design.
A browser notification displayed by an open page is not the same as a push notification delivered when the page is closed.
A more robust implementation can involve:
- A service worker to receive push events where supported.
- The Web Push API to deliver notifications to subscribed browsers.
- A backend capable of scheduling and sending push messages.
- Persistent storage for reminders and their delivery status.
- Appropriate permission handling and user consent.
For deadline-based reminders, the application also needs to distinguish between when a task is due and when a notification should be sent.
For example, if a task is due at 10 AM on Friday, a user might want a reminder on Thursday morning, another shortly before the deadline, or both.
These are scheduling decisions that ordinary backend logic can handle without repeatedly asking an AI model.
A future version of Nudgify could combine dependable notification infrastructure with AI-assisted task interpretation, producing a system that is both helpful and predictable.
That distinction matters: a clever assistant is not much use if its reminders never arrive.
🦥 7. What Does “Slow and Steady” Mean in Practice?
For me, this theme is about more than helping someone procrastinate comfortably.It's about being intentional with the work we ask people to do.
There are many repetitive tasks that don't require our full attention, but still consume time because we haven't automated them.
We repeatedly check deadlines. We reread task lists. We try to remember conversations. We manually organize information that could be structured automatically.
Some of these activities are necessary. Others can be simplified.
Nudgify explores the second category.
Imagine a student who has several assignments due in the same week.
Instead of repeatedly opening different lists and calculating which assignment needs attention first, a well-designed assistant could present the next relevant task and help the student stay aware of approaching deadlines.
Imagine a friend who regularly forgets to follow up on a commitment.
An assistant could help make the commitment visible at an appropriate time, reducing the need for another person to remember to remind them.
Imagine a user who has a long list of tasks but feels overwhelmed by it.
A carefully designed interface could make the next action easier to identify instead of presenting an intimidating wall of unfinished work.
None of these ideas requires an AI model to do everything.
They require a thoughtful combination of automation, reliable scheduling, useful interface design, and AI where it genuinely improves the experience.
The aim is to save attention, not simply to produce more notifications.
🌱 8. What I Learned From Thinking About Open AI
One thing this project highlights is that building with AI involves much more than choosing a model.You need to think about how the model fits into the application, what data it receives, where inference takes place, and what happens when it isn't available.
You also need to understand the difference between an open-source framework, an open-weight model, and a hosted service.
These terms are related, but they aren't interchangeable.
An open-source framework can provide an inspectable and modifiable implementation without making the model it calls open-weight.
An open-weight model makes its trained weights available under a particular license, but that doesn't automatically mean every part of its training data, development process, or surrounding infrastructure is open.
And a hosted AI service can be useful without giving you control over the model's deployment.
Recognizing these differences helps developers make more informed architectural decisions.
For Nudgify, the interesting direction is to keep the application flexible enough to experiment with open-weight inference while maintaining a clear separation between AI-assisted features and ordinary application functionality.
That flexibility would make it easier to evaluate different models based on practical criteria such as response time, resource requirements, instruction-following ability, privacy considerations, and licensing.
It also creates opportunities to learn more about inference, model deployment, and the trade-offs involved in bringing AI from a prototype into a usable product.
For me, that's one of the strongest arguments for open innovation: it turns AI from something you merely consume into something you can actively experiment with and learn from.
🚀 9. Where I'd Like to Take Nudgify Next
There are several directions I'd like to explore as the project develops.1. A genuinely interchangeable model layer
I want the application architecture to make it easier to compare models and switch between compatible inference backends without rewriting the entire application.That would make experimentation more practical and reduce unnecessary dependence on a single provider.
2. Local inference where it makes sense
Running a model locally could make selected AI features available without sending every request to an external service.The exact experience would depend on the model, the user's hardware, and the application's other dependencies.
A lightweight model may be sufficient for some tasks, while more demanding operations may still benefit from hosted inference.
3. Better deadline-aware workflows
Reminders should be connected to meaningful task information.The application could help users distinguish between upcoming deadlines, overdue tasks, and commitments that need attention soon.
The goal is to make information actionable rather than simply adding more items to a list.
4. More reliable notification delivery
A reminder system should be designed around dependable delivery, including appropriate handling of permissions, scheduling, and delivery failures.That infrastructure would allow the assistant to be useful even when the user isn't actively looking at the application, where browser and platform capabilities permit.
5. Privacy-conscious data handling
As the application grows, I want to pay more attention to what information is stored, what information needs to leave the device, and how user data is protected.Local inference could help with some of these decisions, but privacy needs to be considered throughout the application rather than delegated to the model alone.
6. A less distracting productivity experience
More features don't automatically make a productivity tool better.I'd rather explore ways to make Nudgify feel useful and unobtrusive than turn it into another application that demands constant attention.
After all, the whole idea is to reduce the amount of effort users spend managing their responsibilities.
💚 10. Why This Project Matters to Me
As a student and developer, I find it exciting that we can build increasingly sophisticated applications without needing to own an enormous infrastructure stack.Modern web frameworks make it easier to build interactive applications, and the growing open AI ecosystem creates more opportunities to experiment with models and inference systems.
But what interests me most is the possibility of using those tools to solve ordinary problems.
Not every useful project needs to revolutionize an industry.
Sometimes, making it easier for someone to remember a deadline is worthwhile. Sometimes, reducing the number of repetitive steps in a workflow is enough. Sometimes, the best feature is one that quietly works in the background and lets the user get on with their day.
Nudgify is my exploration of that idea.
The project brings together productivity, automation, and AI with the intention of making everyday responsibilities a little easier to manage.
And the Slow and Steady challenge provides a particularly fitting reminder that good technology doesn't always have to encourage people to move faster.
It can also help them waste less energy on things that don't deserve so much of their attention.
🏁 Final Thoughts
The future of AI shouldn't be limited to massive models, expensive APIs, or applications that send every task to a remote service.There is room for smaller models, local inference, open-source tools, and carefully designed systems that solve specific problems well.
Open innovation gives developers more opportunities to experiment with these approaches, understand their limitations, and decide which trade-offs make sense for their users.
For Nudgify, that means exploring how an AI assistant can help people remember what matters, automate repetitive work, and spend less time managing their own productivity.
The bigger lesson is that automation isn't necessarily about doing more.
Sometimes, it's about making room for less stress, fewer unnecessary steps, and more time for the things we actually care about.
Build something useful. Automate the boring parts. Keep the technology open where it matters. And remember: you don't have to rush to make progress. 🦥
🔗 Project Links
- GitHub Repository: [Add your Nudgify repository link]
- Live Demo: [Add your deployed application link]
- Demo Video: [Add your demonstration link, if available]
I'd love to hear from other developers: What's one repetitive task you'd automate with an open-weight AI model, and would you run it locally or in the cloud?
Let's build tools that save people time, energy, and attention.
Hacktoberfest #SlowAndSteady #OpenSourceAI #OpenInnovation #ArtificialIntelligence #AI #WebDevelopment #React #TypeScript #BuildInPublic #DeveloperCommunity
#devchallenge #hf26challenge #software #coding #development #engineering #inclusive #community
Nudgify -
The tech industry has a strange contradiction right now.
Companies are investing billions in artificial intelligence, building new platforms, shipping increasingly sophisticated products, and talking about unprecedented productivity gains.At the same time, thousands of developers, engineers, designers, QA specialists, and other technology professionals are facing an uncertain future.
According to TechRepublic's October 2026 tech layoffs report, nearly 200,000 people had been affected by reported technology-sector layoffs as of October 23.
That number is difficult to ignore.
But behind every headline is a more personal question:
How do you build a sustainable career in an industry that keeps changing the definition of valuable work?
Let's look beyond the headlines and explore what these layoffs mean for developers, why AI isn't the whole story, and how we can prepare for an increasingly unpredictable technology landscape.
1. The Layoffs Aren't Just Numbers on a Dashboard
When a company announces a workforce reduction, the news is usually presented through percentages, headcounts, and stock-market reactions.
For the people affected, the experience is very different.
It's the developer who spent five years maintaining a critical service.
It's the QA engineer who prevented production incidents nobody outside the team ever noticed.
It's the infrastructure specialist who kept systems running during the most difficult outages.
It's the junior engineer who finally landed their first job after months of interviews.
These professionals don't suddenly lose their knowledge, experience, or ability to solve problems when their employment ends.
Yet a layoff can make even experienced engineers question their value.
One important distinction is worth remembering:
A company eliminating a position does not automatically mean the person occupying it lacked value.
Organizations restructure for many reasons, including financial pressure, acquisitions, overlapping responsibilities, strategic changes, and shifting investment priorities.
Some reductions are connected to AI. Others aren't.
For developers, understanding that distinction matters. Otherwise, it's easy to interpret every layoff as evidence that a particular skill or career path has become obsolete.
The reality is more complicated.
2. Is AI Replacing Developers, or Changing What Developers Do?
This is probably the biggest question in software engineering right now.
AI coding assistants can generate boilerplate, suggest implementations, explain unfamiliar code, create test cases, and help developers explore possible solutions.
These capabilities are useful. Ignoring them entirely isn't a particularly strong career strategy.
But the conversation becomes less useful when we reduce everything to a simplistic prediction: AI will either replace all developers or never replace any of them.
Neither assumption helps us make better decisions.
Consider a typical feature request.
An AI tool might help generate an API endpoint in minutes. However, delivering that feature safely may still require someone to:
Understand the business requirements and identify missing assumptions.
Design the API contract and choose appropriate data models.
Evaluate authentication, authorization, and data privacy risks.
Test edge cases, failure modes, and unexpected inputs.
Review database performance and concurrency behavior.
Integrate the feature with existing services and deployment pipelines.
Monitor production behavior and investigate incidents.
Generating code is only one part of delivering reliable software.
The challenge is that AI can make some tasks faster while also changing how much work a team needs to complete them.
That can create real workforce pressure, particularly when organizations expect smaller teams to deliver more.
And there's an important caveat: AI adoption and layoffs happening at the same time do not prove that AI directly replaced every affected employee.
TechRepublic's reporting highlights this distinction. Some companies have explicitly connected restructuring to AI-focused strategies, while others have cited different organizational or business reasons.
For developers, the practical takeaway isn't to panic or dismiss AI.
It's to learn where these tools are useful, understand their limitations, and become better at the engineering decisions surrounding their output.
3. The Real Competitive Advantage Is Engineering Judgment
If AI can generate a plausible implementation, what makes an experienced developer valuable?
Increasingly, the answer is the ability to determine whether that implementation is actually correct, maintainable, secure, and appropriate for the problem.
Imagine an AI assistant generates a database query that works perfectly against a small development dataset.
Will it still perform well when the production table contains 200 million records?
What happens when two requests update the same resource simultaneously?
Could the query expose information that the requesting user isn't authorized to see?
Does the implementation introduce a subtle regression in another service?
These aren't merely code-generation problems. They require engineering judgment.
The same principle applies to testing.
A test suite can report 95% code coverage while missing the business-critical scenario that causes a production outage.
A generated test can confirm that a function returns the expected result without checking whether the result itself makes sense.
A passing build doesn't guarantee a reliable system.
This is where developers can differentiate themselves.
Focus on capabilities that help you reason about the entire system:
System design: Understand service boundaries, data flows, failure modes, and trade-offs.
Debugging: Trace problems across application layers rather than guessing at isolated symptoms.
Testing: Design meaningful assertions, boundary tests, integration tests, and failure scenarios.
Security: Recognize vulnerabilities that aren't obvious from a successful demo.
Performance: Understand latency, throughput, resource consumption, and scaling constraints.
Communication: Explain technical decisions and their consequences to people with different backgrounds.
These skills aren't immune to automation. AI can assist with many of them.
Their value comes from knowing how to apply them, verify results, and take responsibility for the outcome.
4. Stop Measuring Your Career by the Number of Technologies You Know
When layoffs dominate the news, it's tempting to respond by learning everything.
A new framework appears, so you learn it.
A new AI tool launches, so you try it.
A new programming language becomes popular, so you add it to your list.
Soon, your learning backlog becomes larger than any project you could realistically finish.
The problem isn't curiosity. It's confusing exposure with capability.
Knowing that a tool exists is different from being able to use it to solve a meaningful problem.
Instead of collecting technologies, build evidence of your engineering ability.
For example, rather than creating five small repositories that demonstrate basic syntax, consider building one application that includes:
A documented API with authentication and input validation.
Automated unit and integration tests.
Database migrations and realistic test data.
Logging, metrics, and useful error handling.
A CI pipeline that runs checks before deployment.
A deployment strategy with a documented rollback procedure.
A README explaining architecture decisions and known limitations.
This project gives you more than a list of technologies.
It demonstrates how you approach the complete software development lifecycle.
If you use AI to build parts of it, document where you used it, how you reviewed its suggestions, and what you changed after testing.
The goal isn't to pretend you wrote every line manually.
The goal is to demonstrate that you can deliver software responsibly.
5. Build a Career That Doesn't Depend on One Employer
A layoff can be especially disruptive when nearly all your professional identity, network, and sense of security are tied to a single company.
You can't eliminate that risk entirely, but you can reduce your dependence on any one organization.
Start by keeping your professional portfolio current.
You don't need to publish confidential company code or turn every weekend into a side-project marathon. You can document open-source contributions, personal projects, technical articles, or lessons learned from problems you've solved.
Next, maintain professional relationships before you need them.
Talk with former colleagues. Participate in technical communities. Share useful findings. Review other people's code. Contribute to discussions where you can genuinely help.
Networking works better when it isn't treated as an emergency activity that begins the day after a layoff.
Also, periodically review your accomplishments.
Don't just record that you worked on a service. Record what changed because of your work.
Examples include:
Reduced API latency by identifying an inefficient database query.
Improved release confidence by introducing integration tests.
Reduced incident investigation time by improving observability.
Simplified a deployment pipeline and removed manual steps.
Identified and resolved a security weakness before release.
Use real measurements when available. Never invent metrics to make a résumé look impressive.
These examples help communicate the value of your work beyond a job title or list of responsibilities.
Finally, if circumstances allow, build some financial breathing room. Even a modest emergency fund can create options when a job search takes longer than expected.
Career resilience isn't only about technical skills. It's also about having choices.
6. Don't Assume Every Company Is Hiring for the Same Kind of Developer
A headline about thousands of job cuts at a major technology company can make the entire industry look closed.
But company-wide reductions don't tell the whole story about individual teams, occupations, or hiring needs.
A company can reduce its overall headcount while continuing to recruit for selected roles. Another company may be expanding its engineering organization while a competitor contracts.
That doesn't mean finding a job is easy. It means the available evidence needs to be interpreted carefully.
When researching opportunities, look beyond the employer's brand name.
Investigate the specific role, team responsibilities, required experience, and business context.
Ask questions such as:
Is the role associated with a core product or a short-term initiative?
What problems will the team be expected to solve?
How does the company measure engineering quality?
Is the position new, a replacement, or part of an expanding team?
What expectations does the employer have around AI-assisted development?
How does the team handle on-call responsibilities, technical debt, and production incidents?
During interviews, pay attention to how people describe the work.
An organization that expects developers to use AI responsibly, review code carefully, and understand production systems may offer a different engineering environment from one that measures productivity primarily by the number of tickets closed.
No interview can guarantee job security.
However, understanding the role helps you make a more informed decision than relying on a company's reputation alone.
7. Junior Developers Need a Different Strategy, Not a Reason to Give Up
For people entering software development, the current environment can feel particularly discouraging.
Entry-level positions often require practical experience, but gaining that experience can be difficult without an initial opportunity.
AI adds another layer of uncertainty because some of the tasks traditionally assigned to junior engineers can now be automated or completed more quickly.
Still, the conclusion shouldn't be that learning to code is pointless.
Instead, aspiring developers should focus on demonstrating that they understand the fundamentals rather than simply knowing how to prompt a coding assistant.
Learn how data structures work. Understand HTTP, databases, version control, testing, and debugging. Practice reading unfamiliar code and explaining why a solution works.
Then use AI as a learning partner.
Ask it to explain an unfamiliar implementation. Request alternative approaches. Generate test cases and investigate whether they are correct. Compare its output with official documentation.
Most importantly, practice solving problems without blindly accepting generated answers.
Build projects that solve real problems, however small. Contribute documentation or bug fixes to open-source projects. Collaborate with other developers. Learn to discuss trade-offs and explain decisions clearly.
Your first opportunity may take longer to find than you expected.
That delay doesn't make the effort meaningless, and a difficult job market doesn't determine your long-term potential.
8. What Engineering Teams Should Learn From These Layoffs
This discussion shouldn't be limited to individual career advice.
Engineering leaders also have responsibilities.
If an organization reduces its workforce and expects the remaining team to maintain the same systems, deliver more features, and adopt unfamiliar AI tools immediately, the result can be increased pressure rather than improved productivity.
Fewer engineers don't automatically mean less work.
Someone still needs to maintain legacy systems, investigate incidents, review generated code, manage dependencies, and understand architectural decisions made years earlier.
If that knowledge leaves with departing employees, the organization may lose capabilities that are difficult to rebuild quickly.
Teams should therefore pay attention to:
Knowledge preservation. Document critical systems, operational procedures, and architectural decisions before organizational changes create gaps.
Quality controls. Establish clear expectations for testing, code review, security checks, and AI-generated contributions.
Realistic capacity planning. Measure delivery outcomes and system reliability, not just the number of tasks completed.
Sustainable ownership. Make sure critical services have adequate support and aren't dependent on one remaining engineer.
Responsible AI adoption. Evaluate tools against real engineering workflows, including their costs, limitations, security implications, and effect on review effort.
The goal should be to improve the way teams build and maintain software, not simply to make smaller teams absorb more responsibilities.
9. A Practical 30-Day Plan for Developers
You don't need to reinvent your entire career because of a difficult news cycle.
A focused month can help you identify gaps and make tangible progress.
Week 1: Audit your current skills
Choose a technical area relevant to your goals. Review your recent work and identify what you can demonstrate confidently versus what you only know in theory.
Update your résumé with specific, truthful accomplishments.
Week 2: Strengthen one practical skill
Choose a skill that supports your existing experience, such as API testing, database performance, cloud deployment, observability, or secure coding.
Build a small exercise that forces you to apply it rather than just watch tutorials.
Week 3: Complete and document a project
Finish a useful improvement or small end-to-end application. Add automated tests, clear documentation, and a short explanation of your design choices.
If you use AI, verify its output and document meaningful limitations you discovered.
Week 4: Improve your professional visibility
Publish a technical article, contribute to an open-source project, share a useful debugging lesson, or reconnect with former colleagues.
Review relevant job descriptions to identify recurring requirements, then compare them with your current experience.
At the end of the month, evaluate what you accomplished.
You may not have a new job, a perfect résumé, or mastery of a new technology. That's fine.
The objective is to build momentum and make your next step more deliberate.
Final Thoughts: Your Career Is Bigger Than This Year's Headlines
The 2026 layoffs are a serious reminder that working in technology doesn't guarantee employment security.
They also highlight the need to think carefully about AI, organizational change, and the skills that help engineers deliver reliable software.
But there's a difference between recognizing that the industry is changing and assuming that your future has already been decided.
You don't control every restructuring decision. You can't predict which company will announce cuts next. You can't guarantee that mastering a particular framework will protect you from a difficult job market.
What you can control is how you learn, how you demonstrate your abilities, how you adapt to new tools, and how you build relationships with other people in the industry.
Don't compete with AI at generating code faster. Learn to build better systems, ask better questions, verify results, and solve problems that matter.
And remember that your worth as a developer isn't measured by a company's headcount spreadsheet.
The industry will continue to evolve. Our task is to keep learning without losing sight of the human judgment, collaboration, and responsibility that good engineering requires.
Let's discuss
I'm curious how other developers are navigating this period of change.
AI and engineering: Has AI meaningfully changed the way you write, test, or review code?
Career resilience: Which skills do you believe are becoming more valuable as teams adopt AI tools?
Hiring: Are you seeing different expectations for junior, mid-level, and senior developers?
Team culture: What can engineering leaders do to help teams adapt without sacrificing software quality or employee well-being?
Share your experiences in the comments. Practical insights from people doing the work are often more useful than another prediction about the future of tech.
Editorial note: This article is an independent, developer-focused perspective inspired by TechRepublic's reporting on 2026 technology layoffs. Layoff totals reflect reported announcements, not necessarily completed job losses. Figures and company circumstances can change as new information becomes available.#discuss #career #ai #programming #software #coding #development #engineering #inclusive #community
Tech Layoffs in 2026: What Developers Should Do When the Industry Changes the Rules -
A campaign lands in your lap and the numbers are flat. The button says "Submit." The page is three paragraphs of feature copy above the fold. You have one experiment slot this sprint, one shared traffic budget, and two candidate changes that both look obviously wrong.
So which one do you ship first?
The useful answer is neither "test both" nor a coin flip. The two changes answer different questions, and one of them is usually wasted if you run it in the wrong order.
The two problems look identical in a dashboard
Both failures surface as the same line: campaign traffic arrives, signups don't happen. To separate them, split the funnel into two questions.- Does the page earn attention? Can a first-time visitor understand the offer within the first screen?
- Does the ask earn commitment? Once the value is clear, is the action obvious, specific, and low-friction?
The first question is about the landing page. The second is about the call to action. A dashboard that only tracks sessions and signups cannot tell you which one broke.
A diagnostic table before you write any code
What the data showsLikely causeWhere to startMost sessions end within a few seconds; low scroll depthThe page does not match the promise in the adLanding pageDeep scroll, pricing or docs section viewed, few form startsThe ask is vague, buried, or costlyCall to actionMany form starts, few completionsForm frictionNeither. Fix the formLow engagement and low action, traffic source unclearTargeting or message mismatch upstreamNeither. Fix the campaign
That last row matters more than it looks. If the audience arriving from the campaign was never a fit, no amount of button rewording or hero-copy polishing will rescue the page. Fixing the targeting is cheaper than any experiment.Why the order matters more than the individual change
A call to action is read in the context of the headline, the proof, the price, and the surrounding copy.That produces two ordering rules.
Rule one: a button cannot fix a page that never establishes value. If visitors leave before they understand what they are being asked to do, a sharper label has nothing to attach to. You will measure noise and conclude that labels do not matter.
Rule two: do not optimize a component you are about to replace. If a page rewrite is already on the roadmap for this quarter, running a careful label experiment on the current page is a throwaway. The result will not transfer to the new layout, because the context that produced it no longer exists.
The second rule is the one teams break most often, because label experiments are fast to ship and feel productive.
Do the math before you commit to either
A small change usually produces a small effect, and a small effect demands a large sample. A page rewrite can plausibly shift behavior by several points; a button label change often moves it by a fraction of one.A quick calculation, runnable in any Python environment, shows how steep that difference is:
import math
def sessions_needed(p_control, p_treatment, alpha=0.05, power=0.80):
z_a = 1.959963985
z_b = 0.8416212336
p_bar = (p_control + p_treatment) / 2
spread = (z_a * math.sqrt(2 * p_bar * (1 - p_bar))
+ z_b * math.sqrt(p_control * (1 - p_control) + p_treatment * (1 - p_treatment))) ** 2
print(math.ceil(spread / (p_treatment - p_control) ** 2))sessions_needed(0.04, 0.045) # a 0.5-point lift on a 4% baseline
sessions_needed(0.04, 0.06) # a 2-point lift on the same baselineOn a 4% baseline, detecting a 0.5-point improvement at 80% power takes roughly 25,000 sessions per arm. Detecting a 2-point improvement takes roughly 1,900. Same campaign, same page, a thirteen-fold difference in required traffic.
Two conclusions follow. First, if your campaign delivers a few thousand sessions a month, a micro-optimization of the button label is probably not measurable, no matter how good the label is. Second, the size of the expected effect should drive the choice of experiment far more than how easy the change is to ship.
A default order that holds up in practice
- Verify the instrumentation. One exposure event per session, assignment logged server-side rather than inferred from a query parameter, internal traffic excluded, bots filtered. Every downstream conclusion inherits the quality of this step.
- Check message match. Put the ad headline next to the page headline. If they describe different things, stop here.
- If message match fails, run the landing page experiment first. Change the hero, the offer framing, or the proof: the elements that determine whether a visitor stays long enough to be asked anything.
- If message match holds and engagement looks healthy, run the call-to-action experiment. Label, placement, and the one or two lines of supporting copy next to it.
- Re-run the call-to-action experiment after any page rewrite. Treat the old result as historical, not as a default.
Step 4 is where a lot of teams want to start, and it is a legitimate starting point, but only when the diagnostic in the table above says the page is already doing its job.
Track what happens after the action, not just the action
A call to action that increases signups while filling the pipeline with people who never come back is a net loss. Before you run either experiment, decide on guardrail events and log them alongside the primary metric:// One exposure event per session, emitted once and cached client-side
trackEvent("experiment_exposure", {
experiment_id: "cta_copy_q3",
arm: "specific-verb",
campaign_id: "launch_aug",
});// Downstream quality signals, tied to the same session
// activation_started, first_key_action, repeat_usage_7dIf the primary metric moves up and a guardrail moves down, that is a trade-off that needs a decision. Guardrails are especially important for landing page experiments, because a page that over-promises will inflate the action rate and damage downstream quality.
Do not change both at once
Running a page experiment and a call-to-action experiment simultaneously on the same traffic makes the result unreadable. You cannot tell whether the change came from the page, the ask, or the interaction between them.If you genuinely need both answers and have the traffic to support it, use a factorial design: four arms, so every page version is paired with every call to action. The interaction term is often the most interesting number in the output, because it tells you whether a strong page makes the label irrelevant. The cost is roughly four times the traffic of a two-arm experiment.
For most campaigns, sequential experiments are the practical choice: page first, then the ask, with each experiment consuming a pre-committed block of traffic. Avoid switching between them mid-run based on how the numbers look.
Link hygiene when campaign traffic is split
If you are routing campaign traffic between page builds and call-to-action experiments, the link you publish becomes part of the workflow. Campaign copy already competes for space with a headline and a button, and long parameter-heavy URLs wrap badly in chat apps and social posts. A short link such as LinkBit keeps the destination compact and readable in the creative. That is a formatting convenience. Your experiment assignment should live in your own instrumentation, not in the link.The short answer
Run the landing page experiment first when the funnel shows that visitors never engage, when message match is broken, or when a rewrite is already planned. Run the call to action first when the page is doing its job and the ask is the weak link, and only when your traffic is large enough to detect the smaller effect you are likely to see.Before either, confirm what your instrumentation measures. Most experiment programs that stall are running careful changes on a funnel they cannot see.#experimentation #conversionrate #landingpages #webanalytics #software #coding #development #engineering #inclusive #community
Should You A/B Test Your Call to Action or Your Landing Page First? -
Short answer: find people through work you can already click on, judge them by five specific pages instead of the homepage, and use the first call to ask what is not included. Those three habits filter out most of the bad options before money comes up.
Where to look
Start with sites you already use in your own industry. Scroll to the footer and look for a "site by" credit. If there isn't one, ask the owner who built it. A referral from someone whose site you can open and poke at is worth more than any directory listing.Other places that work:
- Industry associations, trade-show exhibitor lists, supplier newsletters — the people who serve the same kind of business you run tend to know each other.
- Freelance marketplaces and portfolio sites. Use them to collect names, not to decide. A platform rating is not evidence about your project.
- Your accountant, your chamber of commerce, a co-working space. Useful mainly when you want someone in your own timezone for calls.
What not to use as a filter: the lowest price, the longest list of services, and any promise about search rankings.
The five pages to open on every portfolio site
Their homepage is the page they spent the most time on. It is the least informative page they have.1. The busiest page. Find the page with the most repeated elements — a product listing, a services index, a team page. Ask yourself: does the layout hold with three items? With thirty? Does a long paragraph still read, or does the text run into the next block? This is the page that resembles your actual site.
2. The contact or enquiry page. Submit a test enquiry with your real email address. Did you get a confirmation? Did the form tell you clearly when you submitted it empty? A broken form on a developer's own site is the single most useful signal you will get, and it costs you two minutes.
3. The mobile version, on your phone, on mobile data. Not on their office wifi and not in a device simulator. Time how long until you can read the headline, tap the menu open, and try to fill the form with one thumb.
4. The second language, if you need one. Do not check whether the words are translated — check whether the pages are. Click three links from the translated homepage. Do they stay in that language, or dump you back into the default one? Does the product list show the same products?
5. The footer pages. Privacy policy, terms, cookie notice. If they build for customers in Europe or the United States and their own site has none of these, that tells you what will be missing from yours.
Two more checks, thirty seconds each:
- Open an address on their site that does not exist — add a few random letters to the end of a page address. A bare server error page means nobody is minding the details.
- Read one portfolio entry properly. Does it say what the client needed, what was built, and roughly how long it took? If every entry is a screenshot with no context, you cannot tell what they did and what was already there before they arrived.
One more thing worth doing: portfolios often include sites the person only partly worked on, or maintained rather than built. That is not dishonest, but it is worth asking directly — "what was your part on this one?" A straight answer is a good sign.
The first call: eleven questions
Ask these before you talk about price. The point is not to catch anyone out; it is to find out whether they have done this enough times to have opinions.1. Who actually does the work? A good answer names the person and says whether any part is subcontracted. A warning sign is "our team" with no names, or a salesperson who will not be involved after signing.
2. What do you need from me, and what happens if it arrives late? A good answer is a written list — logo files, company text, product photos, product data, hosting login — plus an explicit statement that the clock starts when the materials arrive, not when you pay. A warning sign is "just send whatever you have."
3. What will I see first, and when? A good answer is a live preview address with a date attached. A warning sign is "we'll send you screenshots."
4. How many rounds of changes are included, and what counts as a change? A good answer gives a number and a definition: text swaps and colour changes are one thing, a new page or a new feature is another. A warning sign is "unlimited changes" — that is not a policy, it is the absence of one.
5. What is not included? A good answer is a list: domain, hosting, business email, copywriting, photography, translation, ongoing updates. A warning sign is silence, or "everything is included."
6. Whose name is the domain and hosting in? A good answer is yours, from day one, and you get the login. A warning sign is theirs, "for management purposes." This is the most expensive mistake on the list — recovering a domain from someone who stops answering is slow and sometimes impossible.
7. Will I have admin access to the site when it's finished, and can I export the content? A good answer is yes, plus a plain explanation of what you will be able to change yourself. A warning sign is "you don't need access, we handle updates."
8. What happens after launch — what's covered, for how long, and what's billed extra? A good answer defines a window for fixing defects and a rate for everything after it. A warning sign is "free support forever", or no answer at all.
9. What is the timeline measured from? A good answer is a number of working days counted from the date your materials are complete. A warning sign is a confident "two weeks" said before they have seen your content.
10. What would make you turn this project down? A good answer names something real — a deadline they cannot hit, a platform that does not fit, a budget that does not match the scope. A warning sign is "nothing, we can do anything." Anyone who has done this for a while has walked away from something.
11. Can I speak to the client whose site you just showed me? A good answer is "I'll ask them" or "they've agreed to be a reference." A warning sign is every single project being off-limits.
Red flags and green flags
Red flags, in roughly the order they should worry you:- No written scope, or a scope that is one paragraph long.
- The domain and hosting stay in their name.
- A price far below everyone else, with no explanation of what was cut.
- Pressure to decide today.
- No preview address — screenshots only.
- Guarantees about search ranking, traffic, or sales.
- A portfolio where every site looks identical, and none of them is in your industry.
- They ask for the full amount up front.
- They cannot tell you what happens after launch.
Green flags:
- They ask about your business before they ask about colours.
- They can show you a site they built that is still running.
- They push back on something you asked for, and explain why.
- The exclusions are in writing before you ask twice.
- They name the person who will do the work.
Payment and paperwork
Two rules that solve most disputes before they start.Do not pay the full amount up front. Split it against things you can see: a deposit to start, a payment when the preview is up, the rest at launch. Milestones tied to deliverables beat milestones tied to calendar dates.
Get the scope in writing, including the number of pages, who writes the text, who supplies the photos, and what happens if you add a page later. If the document does not mention something, assume it is not included.
Before you contact anyone: thirty minutes of prep
Write these down and the conversation becomes much shorter:- One paragraph on what the business does, who buys, and the single action a visitor should take.
- Three sites you like, and one specific thing about each. Not "it looks nice" — "the product table fits forty items on one screen without scrolling sideways."
- The materials you can supply today, and the ones you cannot.
- A budget range, and a date you genuinely need it by.
- Two developers to get quotes from, not five. Comparing five quotes against a one-page brief teaches you nothing.
The quotes you get will only be as good as the brief you send. And a developer who asks you good questions is telling you they have been burned before — that is usually the one worth a second call.#career #freelance #webdev #software #coding #development #engineering #inclusive #community
How to vet a web developer before you pay: which pages to open, which questions to ask -
Just added: King George V Wall Box in Felpham, West Sussex. View it here: https://postboxmap.co.uk/r/PO22-39 #PostboxMap #UKPostboxes #Postbox #KingGeorgeV #WallBox #StandardRed #Felpham
-
Just emerged from our cardiac walkers' group planning meeting (it's an away game this weekend at the coast) to hear that Greg Lynn has been denied bail. Good. Suck it up mate.
-
Just ended an awesome week in #Berlin. The #streetart game is pretty amazing. I know #newyork is famous for the #art on trains, but Berlin is also known for it’s #graffiti also.
Here are a few that caught my eye.
-
Just ordered four kinds of springtails for a #bioactive cage setup!
(Setting up to get pet #rats.)
-
Just seen a bunch of kids, maybe 7 or 8 years old going to school alone on the Tokyo metro. I thought I was pretty independent walking to school alone at 8 but this is so much more impressive, lol
-
Just consuming this bit of tasty #BBCmicro history, in which two uni students create the first "true" #3D game (defined in the video as "xyz tracking for player and all objects," differentiating from contemporaries like Battlezone and the arcade Star Wars, which were 3D vector graphics, but gameplay was "on rails").
Just as fascinating to me, an 8-bit kid but not from the UK, is the short history of the BBC Micro itself. True public service. Good job, 1970s BBC.
But having spent considerable time in the 90s playing Xwing, Tie Fighter, etc, this story of what was done on a system with the same CPU as the C64, at the time, is really quite mindblowing.
I will probably have more thoughts about this but gotta get chorin'
https://www.youtube.com/watch?v=lC4YLMLar5I
edit: ok two quick thoughts
First off, this video includes the line "that resistor simulates an engineer's finger on the board - it wouldn't boot without it, and to this day nobody knows exactly what it does."
Also, I find the graphics, particularly the edges, fascinating. This machine didn't have "fuzzy logic" about whether to light a pixel or not, and I think the edges of objects, the weird details, reveal some kind of extremely lean rendering routines.
-
“Just Like Kidnapping” https://www.motherjones.com/politics/2026/10/guantanamo-bay-somali-immigrants-ice/?utm_source=dlvr.it&utm_medium=mastodon via @MotherJones
-
"Just, like, be a browser" is like saying "just, like, be a building"
A browser has many functions. A browser can do lots of things for lots of people. Your browser needs will not necessarily be the same as others. Your experience of the web and what you value about it might not be the same as others.
"Just be a browser" implies a uniformity that doesn't match reality
"Just be a browser"... makes you sound like a moron.
-
Just plugging a couple of masterpieces, that's all...
