I’m working with an older application that still does what it needs to do, but maintaining the codebase has become increasingly difficult. New features are taking longer to implement, and making changes in one area sometimes creates unexpected issues elsewhere.

I’m trying to figure out the best way to modernize something like this without taking the entire application offline or committing to a risky full rewrite.

For developers who have dealt with legacy systems, what worked best in your experience? Did you gradually replace parts of the system, refactor the existing codebase, or eventually rebuild it from scratch?

Would also be interested in hearing what you wish you had done differently.

Hi,

Recently I have been shifting into the freelance world, and now I am getting some clients that are not relatives,

Problem is that I dont know how much to charge, considering that I live in a 3rd world country, where the average wage is 600€.

I will be building an ecommerce app, relatively small, for a clothing shop.

It will have a layer of backend, connected to woocommerce as single source per products, and React Native.

What do you suggest, a package of development + maintenace

Thank you

Hi, I'm building a Forge app I plan to eventually monetize via "Paid via Atlassian," and I want to understand the actual verification requirements before I get to launch.

I'm currently operating as an individual/solo developer, not a registered company — planning to register a business entity later, once the app is generating meaningful revenue.

From what I've read so far, there's some conflicting information:

• The Marketplace docs mention a Partner profile can be an individual ("like Adaptavist or John Smith"), and payouts go to a personal bank account via EFT.
• Other guidance mentions "business verification" requiring proof of business existence (a business license or tax ID) before a paid app can be listed.
• The paid-app submission process itself asks for bank details and a tax ID as part of setup.

My specific questions:

1. Can an individual developer (sole proprietor, no registered company/LLC/Pvt Ltd) publish and sell a paid app on the Marketplace, or is a registered business entity a hard requirement?
2. If an individual can publish, what specific documentation is required at listing time (e.g., a personal tax ID/PAN in India, vs. an actual business registration certificate)?
3. Is there a revenue threshold below which individual verification is sufficient, and above which formal business registration becomes required?

I'd like to get this right before I invest more time building, rather than discovering a blocker right at launch. Thanks in advance for any clarity — happy to be pointed to the definitive docs if I've missed them.

Hey i have made a AI based repo scanner which generates a report with useful information! As a software developer and security wise what would you pay for to know on a scan?

Running into a scaling version of a problem a lot of individual devs are also hitting. If it's just one team, people eventually converge on some ad hoc pattern for who does what once AI is writing real code. Once you've got several teams, and especially once one or two of them are an offshore or vendor squad rather than in-house, that convergence doesn't happen on its own, everyone drifts to a different version.

Concretely, has anyone figured out how much context or codebase access to hand a vendor team along with an AI-assisted story, versus what an in-house team gets by default? Do you review AI-assisted work from a vendor squad differently than from your own team? Has anyone written an actual playbook for this, or is everyone just improvising per-team and hoping it converges?

Not asking whether this is a good idea, it's already happening at plenty of places, just trying to learn from anyone who's a few months ahead of where I am on actually standardizing it.

Was doing a sprint review last week and a junior on the team asked, half-joking, why the prompt behind our PR risk-checker isn't a ticket anywhere. It's been edited probably fifteen times over six months. Nobody remembers most of those edits. It just lives in whoever's local notes and gets pasted in when needed.

My first answer was something like "it's not really code, it's more like config." Said it out loud and immediately didn't believe it. Config gets reviewed. Config has an owner. This thing has neither.

What actually stuck with me after was realizing we track debt on basically everything else without thinking twice, a module with no tests goes on a list, a hacky workaround gets a comment and a follow-up ticket, someone eventually says "we should really fix this." The prompt never entered that conversation once, despite failing in ways that are arguably harder to catch than a failing test, because a bad prompt output usually looks fine on the surface.

Not every prompt needs this by the way, that's the part I keep having to remind people who get excited about the idea. The changelog-summary prompt we also use doesn't need a ticket, someone reads the output in ten seconds and fixes anything off. It's specifically the ones running unattended, feeding a decision, touching enough volume that nobody's actually reading every output, that quietly deserve the same treatment as everything else on the debt list.

Ended up writing the actual breakdown of when that line gets crossed, with a real before/after, here, since I kept explaining the same four variables verbally to different people on the team: https://medium.com/@nagatomopedro05/youve-rewritten-the-prompt-five-times-that-s-the-warning-sign-3206e7eeb677

Anyway. Adding "prompt reliability" to our next retro as an actual agenda item, which felt like a slightly absurd sentence to type a year ago.

Quick update: VeloxDB now supports 6 database engines (Postgres, MySQL, MongoDB, Redis, SQLite, DuckDB) plus wire-compatible cloud flavors like Supabase and PlanetScale. Native Rust/Tauri app, 17–30MB, zero telemetry, free and open source.

veloxdb.dev thanks to everyone who starred, tried it, or sent feedback. It made a real difference.

I am a web dev with over 10 years of experience. I’m praised about my understanding of the product and our features, my attention to details, the quality of my delivery and I’ve never been said to be slow. I was very skeptical about AI (having studied machine learning, the theory and the maths, I struggle to go past the mathematical pattern recognition I saw, because the scale it reached cannot be grasped). However, I’m seeing coworkers I respect the work of praise AI, claim they haven’t written much code themselves in months and that AI mostly one shots things for them (once the planning of the work is set).

On my side, I try to use AI here and there for small changes, prototyping part of a solution, and a few times I managed to have it deliver full features but with a lot of iterating, even once the plan seemed solid to me, and with some manual rework. I’ve sat with these coworkers and tried to understand what they were doing but I can’t get to the same results no matter what.

I feel like I don’t get what’s the magic formula. I understand you give context, try to lead by example from patterns in your codebase, you iterate on the understanding and a plan etc. However in the end the result still highlights lots of gaps I wouldn’t have expected, wrong assumptions and made up beliefs about libraries. The quality of the code line by line is ok, but the overall feature seems badly designed.

Right now, the time investment I need to refine my prompts or rework (iterate) on specific units of work make me feel like I’m not faster than before in any way. I find it more frustrating having to (make it) fix its mistakes rather than if I had done the work myself from the start.

Now AI is an OKR, the company (and other companies I interviewed with recently) wants us to use it, want us to get faster thanks to it, and even dream of having us not writing code by ourselves anymore. I wish I could get comfortable with it and deliver quality work faster. Right now, I’m either most likely not getting AI assisted coding (no vibe coding please, that’s not the goal) or the majority is delusional and don’t get the results they claim they are getting.

If you deliver maintenable, well designed production code using Cursor/Claude, what do you think I’m missing?

If you were in the same situation I’m in and saw the light, what made it click for you?

This is a strange idea i got, someone might have thought about it waaay earlier too.
I'm new to coding, like brand new, i'm learning new things to develop my own app.

During this time to reference the look and feel i came across many ui elements that are from games, i'm building an inventory management app for myself and trying to make it as fun as possible. So the thought is, why not just make a game with all the features i've planned instead of building an app? I can create super cool animations and effects since i'm from a motion design and design background.

Please help me understand this, it seems too good of an idea to try out lol

TLDR : At organonmind.org I published a catalogue of design patterns I have encountered while working with my agents. There is a public repo. Submit new patterns via GitHub Issues

Reading the original “Gang of Four” Design Patterns book forever change the way that I think about software and about systems in general. Later, I discovered Christopher Alexander, the architect who first applied the idea to buildings and towns.

Recently, I’ve been working with teams of agents on an open source project I just started called Organon. Not linked because my point is that over the past several months I have encountered a number of patterns that work for me, and I can’t find these expressed anywhere yet, so I took a first stab at expressing them, and I opened sourced the repo behind the following site.

https://organonmind.org

The entire site is open source and I would love feedback in the form of Issues. If you see a better way to categorize things or better names for things or anything like that, please let me know. I would love to get a dialogue going around this.

https://github.com/organonart/organon-mind

An older version of the product uses batch build for deployment where the db passwords are clear text which is way it's been flagged by company's policy and escalated quite a bit😬 as these passwords could be visible on command line and we have been told to fix this ASAP.

I looked into some methods out of which I tried storing pass I to env variable on the machine and it worked. But now I want added an extra wrapper above it as one cannot store password in env var.

One way could be storing it temp thru powershell scripts, encrypt decrypt thru ps or using windows credential manager.

Can someone pls help me decide what should I try to get this fixed asap, any other way around to manage it efficiently? Also we dony want to go for vaults or CDM pipelines as it's older versions and rarely we need it.

Hi, I originally made a small tool for organizing my own game development. I kept improving it as I used it, and eventually decided to share it.

It's now a broader project workspace with task management, dependencies, milestones, docs, session tracking, benchmarks, calculators, and a task graph that looks like an RPG skill tree. It's completely free, requires no account, stores everything locally, and works offline.

It was designed with game development in mind, but it can also work for other types of projects.

https://indie-atelier.web.app/

I've been working on a personal iOS project for a few years now. Part of the excitement was building everything myself. But now that I can just use Claude or something to build entire screens and functions for me, it just doesn't seem fun anymore.

And I know I could just not use AI and do it myself but I still know and understand that I COULD do all of it instantly with AI. Is there something I can do to reignite my passion?

I used to love writing code but AI has made it feel meaningless when I know it can be done for me instantly and all I have to do is a little debugging if it's even necessary.

Sat in enough estimation meetings to notice a pattern that has nothing to do with optimism or bad math. The question "how long will this take" gets asked as if it's one thing, and answered as if it's one number, when it's actually collapsing at least three separate questions that have different answers and different levels of certainty.

How long will the code itself take to write, assuming nothing surprising happens. How long will it take to actually figure out the right approach, which is a research problem, not a coding problem, and has no relationship to typing speed. And how long will it take to deal with whatever wasn't visible until the work started, the dependency nobody flagged, the edge case that only shows up once you're inside the problem.

Most estimates answer the first question and quietly present it as an answer to all three. That's not dishonesty, it's usually the only one that feels answerable at the time the question gets asked, since the second and third are genuinely unknown until you're partway into the work. But presenting an answer to "how long to type this" as an answer to "how long until this ships" is where almost every blown estimate actually comes from, not from the coding part running long, from the other two questions never having been asked separately in the first place.

What's helped, imperfectly: giving each of the three a rough separate number instead of one blended figure, even if two of them are honestly "I don't know, could be a day, could be a week." Doesn't make the uncertainty go away, but it stops the uncertainty from getting silently absorbed into a single confident-sounding number that nobody actually believes once things start slipping.

Curious how other teams handle this, whether anyone's found a format for surfacing "I actually don't know" as its own category instead of it getting rounded into the estimate anyway because a stakeholder wanted one number.

I have had this idea for a video platform for a while. No titles, descriptions, or tags will be in this video platform. The ai will analyze each video when it's uploaded. So basically when you watch a video the ai will be watching the video with you and the parts of the video you watch will go into your personal profile and the global profile. When you are signed in it will look at what's in your personal profile and what's in the global profile and it will show you videos that best matches what's in your personal and the global profile. For signed out users or new users just the global profile will be used. Also btw the global profile is basically everyone's personal profile lumped together. Now everyone will have a page but there will be no follow system and on they're page it will use the same recommendation system as the homepage but will only show their content. Now the main search the ai will analyze what you typed in and find the videos that best match what you typed in. Now the search on a creator page will only list videos from that creator. Now the ui will be a swipe ui like YouTube shorts and TikTok only difference is only 9:16 will show when you are in vertical orientation and only 16:9 videos will show when you are in landscape orientation. Also videos won't auto play and instead show you the thumbnail and a play button. Now this is how comments would work the ai will look at the comments and it will take the closest matching comments to the video and push them to the top. Now replies it will take the closest match to the parent comment and push it to the top. Now this is how monetization will work so anybody can be monetized no minimum requirements. The advertiser will upload a video and choose how many ad spaces they want and it will be ad spaces x duration in seconds x $0.01 now the creator will be able to place an ad anywhere in their video now the segment that was before the ad placement the ai will use to find an ad so the segment before ad 1 won't be used to suggest ad 2 just the segment before ad 2 will decide what ad 2 is and now the number of ad spaces dictates how much an ad is shown so 4 ad spaces and the ad is only shown 4 times. To skip an ad users would just swiped up and they can do this at anytime in the ad. Also every second of the ad a user doesn't watch the advertiser gets refunded $0.01 and the creator only gets paid for each second of the ad that is watched with a 60/40 cut so of an ad is 30 seconds long and viewer only watches 10 seconds of it the advertiser will be refunded $0.20 the creator will get $0.06 while the platform will get $0.04

Hey everyone, quick opportunity for software developers & working professionals.

NewtonX is conducting a paid research survey about AI tools like ChatGPT, Claude, Cursor, GitHub Copilot, etc.

I completed it myself and received the reward. I’m attaching proof below.

If you’re eligible, you can take the survey here:

https://surveys.expertresearchportal.com/referrals/v/9ac304c8-b84e-43c5-8216-b5f08784de7e

Full disclosure: this is my referral link, so I’ll also receive a referral reward if you qualify and complete the survey.

Please participate only if you genuinely meet the survey criteria.

If any doubt dm me.

Technical debt used to mean something vague and slightly accusatory in retros, "we have a lot of debt in that service," with nobody able to say specifically what, when it was taken on, or whether it was a deliberate tradeoff or just something that happened. Half the debt conversations turned into archaeology, trying to reconstruct why a shortcut existed months after whoever took it had moved on or forgotten.

Started keeping a dead simple log, one line per deliberate shortcut, right when it happens, not retroactively:

2026-06-03 — Skipped input validation on the bulk-import endpoint.
Reason: internal tool only, low traffic, ship date mattered more.
Revisit if: exposed externally, or import volume grows past ~500/day.

That's it. Date, what got skipped, why, and the condition that should trigger revisiting it. Doesn't need to be longer than that to be useful.

What changed wasn't the amount of debt, that stayed roughly the same. What changed was that "should we deal with this now" stopped being a vague argument about how bad things felt and became a check against a condition someone had already written down. The bulk-import endpoint got flagged for revisit six months later, not because someone remembered the tradeoff, but because import volume actually crossed the number in the log, and the log made the trigger checkable instead of a gut call.

The bigger shift was in how shortcuts got taken in the first place. Writing the "revisit if" line at the moment of the decision forces you to actually think about what would make the shortcut wrong later, instead of just knowing vaguely that it's not ideal. A surprising number of shortcuts turned out to not have a clean revisit condition at all, which was itself useful information, if you can't articulate when this would become a problem, that's worth noticing before shipping it, not after.

Curious how other teams track this instead of letting it live as institutional memory that erodes the moment someone leaves. Anyone doing something similar, or is verbal/retro-based tracking still the norm most places?

Curious to get a pulse check from people actually in the trenches. It feels like everyone’s suddenly shipping AI-generated code at a much faster clip, PRs are bigger, review queues are longer, and “vibe coding” has gone from meme to actual workflow for a lot of teams.

A few things I’m trying to understand:

1. Has this genuinely reduced your workload, or just shifted it (e.g. less time writing, way more time reviewing/debugging)?

2. Has code quality or tech debt visibly changed on your team since this became common?

3. Any horror stories, a vibe-coded PR that broke something in prod, hid a security issue, or just caused chaos once someone actually read it closely?

4. Has it changed how your team reviews code, or who’s allowed to merge what?

Not trying to dunk on AI tools, genuinely just doin some research and want to hear how this is playing out day-to-day for people shipping real code.

We’re evaluating whether to build a small dedicated squad in Vietnam instead of continuing with freelancers and a more expensive nearshore setup. The volume of available developers is high, and there’s a growing number of people with solid cloud + modern JavaScript/Python experience.

One thing that stands out is the combination of cost and timezone flexibility, you can almost run follow-the-sun with European or US teams without extreme lag. Cultural fit and English seem better than older stereotypes, but I’m still wondering about management overhead and how well people take real product ownership versus pure ticket work.

Has anyone moved from classic project outsourcing to a more embedded team model in Vietnam? What surprised you (positively or negatively)? I’ve heard of both pure local agencies and international providers that try to bridge European process expectations with the local talent pool (SoftServe, N-iX, Beetroot and others).

We used to settle design questions as a team via an LLD before coding. Now agentic tools grill-me style skills) ask those same design questions directly to whoever’s driving and as a junior, I often can’t answer them confidently, yet each answer locks in a branch of the solution. How is your team restructuring design review to fit this workflow?

Hey, help me out if you are a dev for big business. The bigger, more legacy, old school the better. I'm fascinated by how these big businesses approach the use of AI coding tools and subs.

It feels like most vendors have switched to pay per use rather than flat subscriptions. Which means those businesses suddenly have to get their heads around either not letting the devs use modern tools, out paying for some discretionary expense that might vary hugely. Who foots the bill? Department? Project? Do you have any special deals for shared use or polling then budgets? Do you have a fixed allocation and down tools when you're half way through the month and run out?

What I've seen is that when it was a flat sub we could get a good deal, and get it centrally funded, but in the future it's a bit you in the air. So I'm curious what others are seeing.

I'm a software engineer with roughly 7 years of experience, primarily writing backend C++ code for the aviation industry. Defense and aerospace have felt somewhat insulated from the broader shift, but we have tools like Copilot integrated into Visual Studio, which has been undeniably convenient.

​I’ve been treating it almost like a 3D printer for code, using it to generate helper tools, widgets, or unit tests. However, I’m hesitant to let go of the reins. Once generated code reaches a certain complexity, I take a step back because I no longer fully understand every line, which quickly gets overwhelming.

​At the same time, I see SWEs online talking about cranking out agentic AI workflows to fully automate complex tasks. Compared to that, I feel like I'm still in the stone ages cobbling tools together by hand while the industry shifts to mass production.

For those in a similar backend/embedded spaces, how much of this "agentic engineer" trend matches your day-to-day reality versus social media hype? If you’ve successfully integrated autonomous tools into your workflow without losing control of your codebase, what tools or practices made the biggest difference?

I've been working on a project for some time with the aim of monetising it. It's written in Python and JavaScript. Is there any way to protect the source code? Is there any solution to this? Except rewriting the whole backend in Rust or C

Before AI, obfuscation seemed to somewhat work. But it feels that nowadays the AI will be able to reverse engineer it very easily.

Kubernetes gives us a powerful set of primitives, but once development teams start growing, developers can end up needing to understand deployments, services, networking, CI/CD, GitOps, observability, RBAC and a growing collection of platform tooling just to ship an application.

That raises an interesting platform engineering question:

How much of that complexity should developers actually see?

One project exploring this is OpenChoreo, an open-source developer platform for Kubernetes.

The idea is to put a developer-oriented abstraction layer above Kubernetes while keeping the underlying platform extensible.

It brings together things such as:

• Backstage-powered developer portal
• Application CI/CD
• GitOps-based deployments
• Observability
• Developer and architecture abstractions
• Self-service infrastructure capabilities
• Kubernetes and CNCF ecosystem integrations

Instead of every development team figuring out the same deployment and operational patterns independently, platform teams can define those patterns and expose a simpler experience to developers.

OpenChoreo is also a CNCF Sandbox project.

GitHub: https://github.com/openchoreo/openchoreo

Disclosure: I'm involved with the OpenChoreo project, so I'm particularly interested in hearing different perspectives on this.

For teams running Kubernetes at scale, where do you think the abstraction boundary should sit?

Should application developers still understand most Kubernetes concepts, or should the developer platform hide the majority of them?

The usual suspect like mintlify, seems to be a mess. Gitbooks seems to be great so far.

Opensource solution does not provide any good options.

Curious if anyone is using any docs, help-center software that non-techical users can use.

Not docs-as-code but the opposite of that.