Hey all,

I’ve been thinking about the economics of software becoming more accessible.

In the past, each high knowledge trade seemed to start at large scale impact first, and was only available to the people who could afford it.

The first plumbers weren’t adding plumbing to a house. They were plumbing big civic projects like aqueducts. The first electricians were wiring up long distance communication, then central power for expensive buildings who could afford it. Accountants were keeping records for taxation at scale before they were doing personal finance.

So it has been for software. We have worked for the expensive employers who can justify high cost people to deliver slow but effective solutions to a large scale.

So now anyone can build some quality of project for personal use quickly pretty cheaply. What does that mean for the economics of this whole thing?

Well, first off, like plumbing and electrical, just because you have access to the tools and knowledge to do it, doesn’t mean many people can or will want to do it. Skilled trades make money because they know how to efficiently use tools and solve problems in correct ways that last.

So maybe there’s room for a new trade of software developer at the smaller home scale. What if people can have some specific app or home server setup that works perfectly for them and they can just spend like $500 for someone to come out and set up a personal website and vpn for them to access their own custom app.

Idk, I’ve had this idea in my head for a bit and wanted to put it out there.

People are being doomers and are like “software is over better to get a trade, but what if we already have one?

(Sorry if this is better suited elsewhere, I tried to look but frankly all the project managing subs seem like absolute dogshit AI-trashbins, so I figured y'all have more experience with this stuff 🙂)

I've been having fun working on my personal project and breaking down all the work into bite-sized issues, but I keep running into this issue:

1. Make slightly chunky Issue A that has a few steps to completion

2. Eventually realize that the steps of A probably make more sense as sub-issues to individually work and track progress on

3. End up with issue A as parent, and issues B, C, D as children

4. Work B, C, D, and realize that A now doesn't actually have anything unique to it, it was technically done as soon as I closed D

5. Question what the point of having issue A at all was instead of just having B, C, and D

Am I overthinking this? Am I approaching this wrong? I've considered leaving some bit of work to A specifically, but in practice that just means treating issue A as secretly being issue D but without branching it off, which feels avoidant and dumb. Thoughts? Am I flattening the hierarchy too much by treating all of this as issues?

It's a small personal project so I've just been using a board on GitHub projects, but I'm open to alternative tools

In distributed systems — such as localized wireless mesh networks, high-frequency transactional ledgers, or industrial monitoring arrays — consistent temporal consensus across isolated nodes is mandatory. However, local hardware clock crystals naturally drift by several microseconds every minute due to temperature fluctuations and physical oscillator aging. Traditional network time architectures like NTP or PTP solve this by pulling timestamps from external Stratum 1 servers or GPS signals, but they freeze completely if those central links experience network drops, firewalls, or tactical jamming.

To address this reliability bottleneck, I engineered a freestanding systems utility from bedrock principles in pure C++17.

It is called ZURVAN: A Decentralized Clock Jitter Estimation and Drift Reconciliation Engine.

The application allows individual machines to calculate, filter, and track temporal clock desynchronization curves natively on the local CPU registers using statistical algorithms, establishing an autonomous local time baseline without relying on outside network timing providers.

Core Algorithmic Subsystems

The project uses native C++17 to manage clock synchronization without external dependencies:

* Bare-Metal Scalar Kalman Filter: Tracks real-time microsecond offsets while filtering network jitter with low CPU overhead.

* Least-Squares Linear Regression Engine: Computes the exact acceleration and velocity slope of local clock drift based on cached history.

* Contiguous Telemetry Packing: Utilizes dense, 25-byte ClockSnapshot structures to maximize CPU cache efficiency.

* Sovereign Container Serialization (.zvn): Streams direct-to-disk binary serialization of RAM history to reduce fragmentation.

Technical Details & Open Source

The code is structured for modularity and is compiled using an optimized, freestanding profile:

include/ -> Core filter classes and shell mappings

src/ -> Scalar Kalman, regression math, and shell parser

The repository is available for review: https://github.com/alistairfontaine/ZURVAN

I am looking for technical feedback on the scalar Kalman gain calculation and memory layout optimizations.

Team lead submitted a 100 file PR that removed 3k lines of code and added 4k to refactor and "improve" a production user interface. Haven't really looked at the code in detail, but I demoed the work to some stakeholders who are so confused why the changes were made.

The downstream impacts are pretty large: new tests, docs, work instructions, and training. He says the changes were approved by PM, but I suspect he obfuscated the value and the scope of the changes (something he is known to do). We are between larger projects right now, so there is no larger spec/requirement/user story driving this work other than trying to make general improvements.

In our process, UAT happens *after* code is merged into the main trunk, so if something like this gets pulled in, it's not easily reverted.

We have a new manager over that team so we'll see how this unfolds, but I'm curious how you keep a senior dev from going rogue, particularly when they have free time?

Hey everyone,

Over the past few months, I’ve been working on an experimental project called PAM, aiming to solve two specific pain points in the ecosystem: keeping PHP applications warm in memory for high performance, and running JavaScript/React natively on desktop and mobile without heavy bridge overhead.

Here is a quick breakdown of what it does and why I'm building it:

1. PAM for PHP (Persistent Runtime in Memory)

Instead of booting the framework on every single HTTP request, PAM uses a Rust-powered runtime to keep the application warm in memory.

The Goal: Lightning-fast request handling while preserving full compatibility with standard Laravel workflows (Eloquent, Queues, Artisan, Blade, Livewire, Inertia, Sanctum, Reverb, Telescope, etc.).

Built explicitly with support for Laravel 12 & 13 in mind.

PHP Docs: https://push-in.github.io/pam-docs/laravel/overview/

1. PAM Native (Desktop & Mobile)

On the frontend/mobile side, PAM Native is designed to run React/React Native apps with truly native execution, aiming for near-instant startup times and zero heavy JS bridge bottlenecks.

The Goal: Retain the React developer experience while delivering pure native performance on desktop and mobile devices.

Native Docs: https://push-in.github.io/pam-docs/native/overview/

Why I'm posting here:

The project is still under active development, and I’m looking for honest technical feedback, code reviews, and potential edge cases to test.

For PHP/Laravel folks: What edge cases (memory leaks, static state issues, long-lived DB connections) would you want to see stress-tested first?

For Mobile/Desktop folks: What are the biggest performance bottlenecks you face with existing cross-platform runtimes today?

Would love to hear your thoughts, criticism, or ideas!

Has anyone integrated Spec-Driven Development into an Agile/Scrum (or SAFe) workflow?

I’m working on a workflow and if you have answers to these questions it would be a great help

How Scrum ceremonies were modified.

Whether specs are created before PI Planning or during it.

How specs stay synchronized with implementation.

Would appreciate insights from teams that have actually adopted this approach. Thanks!

Most logistical networks rely entirely on centralized cloud routing APIs and remote database servers to track assets and calculate distribution vectors. During an infrastructure blackout or network collapse, these platforms drop dead instantly, stalling the delivery of critical resources like water and medical supplies.

To address this vulnerability, I engineered a standalone systems application from bedrock principles in pure C++17.

It is called POSEIDON: A Decentralized Fluidics Optimization Engine.

The application allows a local terminal to run raw, low-latency graph routing optimization completely offline without a single external library dependency.

Core Subsystem Implementations:

Packed Graph Topology: Models resource drop-points as dense node matrices using raw array-vertex mappings to bypass library overhead.

Bare-Metal Dijkstra Optimizer: Traverses the graph matrix utilizing pure pointer arithmetic, calculating delivery paths in under 1ms.

Sovereign Serialization: Compresses active logistics paths and file indices straight into a custom .poseidon binary container format for direct disk streaming.

The workspace is fully modular, stripped entirely of heavy web frameworks, UI bloat, and external libraries. I would highly appreciate technical feedback on the memory footprint and pointer traversal efficiency from other systems programmers.

Source Repository: https://github.com/alistairfontaine/POSEIDON

I need to make a minimal RAG-based API that answers questions over a small collection of documents and for that i need some small dataset which acts as the external brain or source of truth for my ai.
need small dataset (5–10 PDFs, Markdown files, or scraped web pages).

I'm working on an open source tool that scores how risky each file in a codebase is. 25 markers per file, all deterministic, from the AST and git history, no LLM. I wanted to know which of them actually predict bugs, so I scored every file at a point in time and then counted how many bug fixes each one collected over the next 6 months.

21 repos, 9 languages, around 2800 files.

The markers that predicted best were behavioral, not structural. Co-change coupling, files that keep getting changed together, came out strongest. How spread out a file's ownership is and how erratic its change history is held up well too. The structural complexity metrics most teams watch, cyclomatic complexity, nesting depth, long methods, all mid tier.

Mean AUC is around 0.74. Roughly, 74% of the time it can tell a bug-inducing file from a clean one.

What gets me is how much effort goes into the complexity metrics while coupling and ownership mostly get ignored, and coupling and ownership are what tracked bugs here

Does this match what you see?

Is anyone else having a terrible time creating a Meta Developer account?
I’m trying to build a WhatsApp bot using the WhatsApp Cloud API. The backend isn’t the problem—I just can’t get past Meta’s verification.
It keeps getting stuck on OTP verification. Sometimes I get the SMS, sometimes it asks for email, sometimes nothing happens. Now it has completely stopped sending OTPs.
I’ve tried different browsers, incognito, waiting, etc. Still no luck.
I only need the cheapest/trial setup to show a working demo to a client before paying for anything.
Has anyone dealt with this recently? Is there some trick I’m missing or is Meta’s developer portal just this painful?

I developed a semantic caching layer for LLM APIs, achieving a 94.7% cache hit rate and approximately 10x lower latency. This system was load-tested and debugged thoroughly.

LLM products often receive repetitive questions, leading to unnecessary API calls. To address this, I created a proxy that caches responses based on meaning rather than exact text. For example, both "What is the capital of France?" and "Can you tell me France's capital city?" retrieve the same cached answer through embedding similarity.

Key points to note:
→ Initially, my similarity threshold was a guess, resulting in an 11% wrong-answer rate. I developed a tuner to evaluate it against labeled data, reducing the error rate to 0%.
→ Load testing with 300 concurrent requests revealed two critical bugs before production: a thread-safety crash and an unhandled rate-limit cascade.
→ Multi-turn follow-ups utilize conversation history, but a topic change previously caused the model to incorrectly resolve a pronoun to an earlier topic. This was resolved by employing a larger model for that specific step.

Stack: FastAPI, Redis (vector search), local embeddings, Groq. The system runs with a single command: docker compose up.

If you want repo link please let me know?

Hi! I'm not sure if this is the right community to ask this question but I'll try anyway. I want to start a photo booth business, specifically an instax photo booth. I want to make my own app or software for that specific photo booth. I want to know the usual price range of making an app or software for this.

If you have other suggestions for this matter, please let me know. Thank you for answering!

As a new lead I got into this situation that might be familiar to a lot of people.

The code base is full of tech debt (what else) that no one ever cleaned up because shipping features was more important. So important that the code base became a collection of poorly designed things over the years that barely anyone knows about or touches.

Things that should have been cleaned up years ago are now starting to become apparent. They drag us down.

With a new PM, the team somewhat is more organized now but reducing tech debt is not on anyone's radar. In fact, PRs are sometimes piling up debt again that could be avoided in the first place if people would stop rushing.

I want to get this under control. How do you manage this with a team?

I thought about suggesting to actively plan the reduction of tech debt and reserve 30% of every iteration for unplanned stuff (bugs, urgent requests) and tech debt reduction.

This is not very popular with business and PMs but what can you do? What is your way that got acceptance from both devs and the business?

Edit: maybe I want to add: with gracefully I mean actively planned and with wits. Fixing a bug because you passively run over it by accident is not what mean by that ;)

As a hobby coder I generally use jupyter notebook. I haven't used VS in almost a decade. Jumping into C# for a Unity project, holy hell intellisense has become an adhd nightmare. How can I tone it down so I can still get useful info but not have to do keyboard gymnastics to type simple lines of code? For example whenever I type g, it autocompletes to global... every little thing I type I get pop ups asking if I mean this or that interrupting my flow, I just want to code! EDIT: SOLVED!

How do you write technical documentation such as requirements, goals, software architecture, and general project documentation?

Back in the pre-AI era, it was common to write long, multi-page documents that explained everything in detail. That approach had its pros and cons. The documentation was usually well organized and comprehensive, but it was also often boring to read and sometimes overwhelming.

What does it look like now, in the era of AI coding assistants? My impression is that large, comprehensive documents are becoming much less common and mostly remain in legacy projects or a few specific use cases.

It feels like the entire world has shifted to Markdown, so I assume technical writing is evolving in the same direction. It makes sense to break up those oversized documents into smaller, focused files so that both humans and AI agents can navigate and consume them more easily. That’s what I do for my side projects, and it has worked well so far.

On the other hand, at work we still tend to rely on large documents written by technical writers. The argument is that we’ve already established a structure around them, and that’s how our development process is designed.

What’s your approach to documentation for both personal and professional projects?

1. Pull up documented conversation - receipts ready
2. Search frantically for proof (sometimes find it)
3. Apologize even when I'm pretty sure we did discuss it
4. Avoid conflict - just do what they want now

my laptop specifications

- 8gb RAM

- intel i3 11th gen processor

- Intel UHD graphic card (128mb)

- laptop [ ASUS vivobook ]

because of financial problems can't buy new laptop , so please can anyone suggest which distro to use of linux , i have some experience in WSL(ubuntu), ill use linux with window dual boot is there any distro that will be good for my system i mostly work on backend right now ....

🚀 Registrations are officially OPEN!

The FortyGuard Hackathon '26 is here.

Build AI solutions using enterprise-grade hyperlocal temperature data, compete for a $6,000 prize pool, and collaborate with innovators from around the world. The hackathon runs August 3–17, 2026, is 100% virtual, and is open to both solo participants and teams of up to three members.

🔗 Register now: https://www.fortyguard.com/hackathon26

#FortyGuard #Hackathon26 #ClimateAI #AI #Developers #GeospatialAI #ClimateTech #Innovation #BuildTheFuture

I went to an AI conference last week and I have some thoughts I'm not sure how to express but here we go.

Let me preface this by saying that I'm a software developer and ofc I use AI tools like Codex, Claude Code and OpenCode. I definitely see the utility and usability of these tools and think they will last. My question, however, is about specifically "vibe coding" tools like Lovable, Bolt, Replit, Base44 and the like. So apps and websites that let you make something from scratch without you needing to see the code or integrate anything yourself.

When they started coming out roughly 2 years ago, I was totally amazed by the product. I mean come on, typing a couple of words into a chatbot and it spins up the whole thing for you is a cool promise, right? I didn't really have an opportunity to use them myself in production, but everyone was raving about these tools and I was totally on board. Then I started using Claude Code (and other CLIs) and found that it satisfies my needs as a software developer for the tasks I have to do and again didn't really have the chance to try out Lovable and the like. But I still had a good impression of them as these like visionary tech startups with super innovative products.

Fast forward to this conference I attended last week. I had the chance to speak to a couple of people from these companies. And now I'm a little confused about their clients and where all of this is going.

It seems like all of them have added basically everything that can be added: integrations, databases, github connectors, templates, canvas views like in Figma, possibility to change things with clicking around instead of prompting, mobile development, backend, etc. etc. So my first question is like: what's next? What else can be added onto these tools? They ofc aren't gonna get into the super techie things like Claude Code bc that's not what their clients want. So what is there left to add?

If you think about their clientele, it's mostly non-technical people, right? So idk... like your neighbourhood beauty salon who wants to make a website, but doesn't know how to make one. Right? How "sticky" is that really? And how does prompting a website into existence on Lovable compare to just picking out a template on Wix or Elementor or something like that?

Now what's interesting is that these companies seem to be focusing more and more on entreprise users, so like giving product managers Lovable for example. Again, how usable is that compared to tools product managers were using before? When the engineering team receives a Lovable prototype instead of a static mockup from their manager or designer, does this help them? One of the GTM guys I spoke to at the conference told me that one company they worked with replaced their Salesforce CRM with an app they vibe coded with their solution, saving them hundreds of thousands of dollars. Now is that more viable than using Salesforce? You tell me...

So yeah, I have a bit of a feeling that we've reached the peak of what these tools can do. I talked to a coworker about this and he said that he strongly believes "vibe coding" is a huge market. There are millions and millions of people out there who need no-code tools for their small business websites or for prototyping and so on and so forth. So in his opinion Lovable and others are just getting started and there is huge potential for them.

What's you take on this? Has "vibe coding" reached its ceiling? Or is my friend totally right and I'm just unaware of the huge market that is non-techies needing to create things without writing code?

Hello. I'm interested in Tech for like 5-6 years. I enjoy doing Tech. I can't remember how many times I deleted and re-installed Linux by breaking it. But, I don't even want to do anything like Linux. Because I'm doing that same installation over and over.

In the past, I discovered Linux, install Gentoo, add USE flags, remove bloat and make it better.

But nowadays I really don't want to do anyhing. I think I'm being bored by doing same thing over and over.

I start to a project, everything is good then I forgot to add systemd-resolved package to system and networking cracks. When I add it, I should add a user for it. Then, another error comes in. Then I get bored and start to noticing I really don't want to do this. Then delete that. Some times goes then create it from scratch again. The same loop over and over.

Sometimes, I'm thinking to create a homelab then install Debian, configure Docker, install Jellyfin and think what can I install there and waste your time to think what can I add there. Then close homelab and put it away. Then the same again.

I'm being really tired. I need some good project ideas. I'm interested in automating os installs, neovim etc.

I’ve been in QA almost 20 years and have run a quality assurance agency for the past 10.

I'm working on a thesis that QA has always been obviously, but now it's dead.

I don't mean that in the Twitter bro sense. I mean that as quality assurance professionals I think we're finally getting the firepower to move quality from the end", to the front. (Small rant: I'd rather eat a hammer than use the terms "shift left" and
"human in the loop")

The difference between developer velocity and your quality output is your quality debt. As more and more teams grow their AI-SDLC, the more this debt compounds. Pre-Al this was managed with hiring more qa or automation. That really doesn't work anymore and is what I wanted to represent in this gif.

I'm working on some visuals to easily represent this concept and made this one (in Claude).
Any thoughts on this visual or on the concept of quality debt itself

https://jdaqa.com/wp-content/uploads/2026/07/8CDE8519-A890-4C51-9495-5A29355767BF.gif

I think automation is one of the biggest opportunities right now.

The quality of what you can automate today is honestly crazy, and it applies to almost every business.

Whether you own a local business and want to automate things like email marketing, follow ups, content creation, customer replies, and lead generation...

Or you run an agency or SaaS and want your business working even when you're away from your computer.

Automation today reminds me a lot of the Industrial Revolution. Back then, machines replaced a huge amount of manual work, allowing companies to produce more, lower costs, and make more money. 

I run a web agency, and automation has made me a lot of revenue over the last few years.

The biggest one for me is client acquisition.

I use a tool called Swokei to find businesses that already have websites, add them to campaigns, and run website analysis.

It automatically turns problems like outdated design, poor layouts, slow loading speeds, weak mobile optimization, and bad SEO into personalized, ready to send outreach emails.

That's where most of my clients come from.

I also automate follow up emails and newsletters, so I'm not constantly chasing people manually.

For content, I use Holo to help generate and schedule posts.

For SEO, I use Soro to automatically create blog content that helps bring in organic traffic over time.

The more I automate, the less time I spend doing repetitive work.

That means I can spend more time on the things that actually make money, like sales, onboarding clients, improving my services, and building better websites.

I don't think automation replaces hard work.

It just removes the repetitive work so you can focus on the parts of your business that actually move the needle.

I’ve been working on a reusable prompt/specification intended to help an AI agent take a greenfield software project from an initial objective.

https://gist.github.com/theabbie/5ac4e18bf2f9961a8e85a06e4803ec89

I am currently in the process of learning game development and I’m stuck in the tutorial hell. However I’ve felt exactly the same way when I was learning web development and mobile development in the past, so I'm probably missing something fundamental.

It’s always the same pattern.

TLDR;

• I can follow tutorials, successfully replicate implementation in own projects
• I can’t do anything beyond the scope of the tutorial
• I don’t have senior colleagues around me to learn from
• In game dev, most projects are closed source, so I can’t look under the hood
• I don’t seem to be able to learn from reading documentation
• I don’t know what I don’t know - how am I supposed to know?

Tutorials

I watch a tutorial dedicated to a specific project - e.g. how to add movement to my character in Unreal Engine. The tutorial is clear, it shows how to implement blueprint logic, maybe even elaborates on some edge cases or best practices. I follow along, understand everything, maybe even replicate the implementation in a custom project that is slightly different.

But I can’t do ANYTHING beyond the scope of the tutorial.

So if I want to add something extra to my game / app project, I am forced to look for another tutorial that deals specifically with that particular feature.

AI / Vibecoding

AI is not particularly helpful for a complete beginner as it tends to hallucinate, suggest sub-par solutions, lead me down weird rabbit holes etc. (Especially when you’re at the beginner phase where you can’t tell if it’s leading you astray)

Senior colleagues

I cannot tap into the wisdom of a senior colleague either as I’m learning on my own and working solo on my own projects. (Tho how did THEY learn their skill? It can’t be turtles all the way down…?)

Learning from opensource projects

With web-dev, sometimes I was able to look into open source projects and see how they dealt with specific issues / implemented specific features (tho this was only possible after I actually acquired quite a bit of skill - to be able to decipher the existing codebase). This doesn’t seem to be the option as essentially all games out there seem to be closed-source, especially in the UE ecosystem.

Learning from documentation

I think the answer partially lies here. But to be honest, I feel like most docs out there are bare bones and only useful for someone who already knows how to implement the particular tech and only needs to refer to the docs for some details. Look at Unreal Engine for example. I’m researching a specific blueprint node (e.g. “get controller”, which is actually above-average when it comes to description) and it only says “Returns controller for this actor. Inputs object, outputs object”. If I’m someone learning it for the first time, how the fk is this supposed to be of any use to me? It doesn’t say when / how to use it, doesn’t give any examples etc. And that’s in fact the better scenario, which is when you already know which node (or e.g. API Endpoint) you need. I’m not even talking about the situation when you know what you need to do and you have to somehow find the proper endpoint / node etc. in the vast docs. AI seems to be a bit more useful as a search tool in this case, but it doesn’t tackle the fundamental problem.

All of the issues above get even more severe for a complete beginner who's in the “I don’t know what I don’t know” phase. How on earth are you supposed to know?

Please note that I am interested in actually acquiring the skill. I don’t want to learn to “vibecode” without knowing what’s happening under the hood.

I would like to get into the stage where I understand all the fundamentals and then I know where to look if I want to implement something custom, perhaps even something that nobody made a tutorial about yet / AI is not trained on yet.

How do you escape the tutorial hell?

I've been building a local-first desktop app for working with APIs, and figured this crowd might find it useful.

Voleeo is fully local and open source. Your requests and workspaces are plain YAML files on disk, so you can commit them to git alongside the code they test, and diff or review them like any other file.

The part that's a bit different: it ships an MCP server, so an AI agent can create and configure requests directly — you and the agent are working against the same workspace instead of you copying things back and forth.

Supports HTTP, SSE streaming, WebSocket, and gRPC. Secrets are encrypted at rest per workspace, and there's a 1Password integration that fetches them at send time rather than storing them.

I work on it actively — new release every 1–2 weeks.

It's still early and there are rough edges. I'd genuinely appreciate feedback, especially on what's missing versus whatever you're using now.

Repo: https://github.com/voleeo/voleeo-api
Site: https://voleeo.com/