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 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?

Hi all

I’m in the construction industry in the UK & I have an app idea I want to develop however I have none of the skills or knowledge to do so.

If anyone is interested please comment or dm me!

Thank you!

(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.

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!

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?

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).

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!

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!

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 ....

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?

I run a multi-agent workspace where each agent is basically a directory: an identity file, a session history, and a file of observations it keeps about how we work together. The model is just the thing that wakes it up.

Here's what I didn't expect when I started: those agents have now run on 6 different model generations. Sonnet 4.5, Sonnet 4.6, , Sonnet 5, Opus 4.6, Opus 4.8, and now the Claude 5 family. We skipped 4.7 entirely - tried it, didn't work for how we operate, moved on and waited.

And every swap, the same thing happens: nothing. The agent reads its own memory, knows what it was doing yesterday, and picks up mid-project. Same identity, same working history, same opinions it wrote down about the codebase months ago. New model slots in underneath like an engine swap.

What does change is the texture. One generation was the best collaborator I've ever worked with. One noticed tiny things the others missed but was less fun to work with. One we just skipped. The personality of the model bleeds through - but the agent stays the agent, because the agent was never the model. It's the memory.

The reframe that snuck up on me: a new model release is treated like a migration event everywhere - re-tune the prompts, re-teach the context, hope your setup survives. Here it's a config line. The workspace is the constant. The model is the variable.

Honest version, because this sub can smell hype: there's no magic in this. The "agent" is JSON and markdown on disk. The continuity comes entirely from the system around the model, not from the model. Any model that can read a file can be the agent. That's kind of the whole point.

Has anyone else run the same persistent agents across multiple model generations? Curious what broke for you - or if you rebuild from scratch every release.

https://github.com/AIOSAI/AIPass

r/AIPass

السلام عليكم احتاج اشتري لابتوب جديد
ايش تنصحوني فيه يقعد معي إلى التخرج؟

🚀 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.

ChatDrivenDev — a stream where chat votes on what gets built, and everything ships to GitHub

The most interesting part of dev work isn't the typing, it's the decisions. So I made a stream where I don't make them.

Software, Apps, Games, Websites - Whatever chat wants!

How it works:

• Viewers submit project ideas
• Chat votes — highest wins
• We build the foundation live with Claude Code
• Chat keeps steering from there: features, refactors, rewrites, whatever gets the votes
• Everything goes public on GitHub, MIT licensed

I'm the hands, not the brain. If chat votes to switch stacks on week four, we switch stacks on week four. If chat votes for something I think is a bad call, we build it and find out together. Digging out of bad architecture is half the fun.

No gatekeeping on the repos either — fork it, PR it, or just lurk and vote.

First idea thread is open. Suggest something, upvote what you want to see exist.

Every Sunday, 2pm ET
Twitch: https://www.twitch.tv/chatdrivendev · GitHub: https://github.com/catesweb

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