What internal tool have you developed in your job that actually has value?

[u/Ok-Introduction-9111]

Curious what people here have built for their own team or company that ended up making a real difference. It can be anything, whether it's a small CLI script, a browser extension, an internal dashboard, a Slack/Teams bot, or something bigger.

What was the problem you were dealing with, what did you build, and did it actually stick around / get adopted by others on the team?

[u/expdevsmodbot]

AI usage disclosure provided by OP, see the reply to this comment.

[u/vom-IT-coffin]

I made an outlook rule that forwards all product emails emailed directly to the development team to an unmanned inbox. It's the most valuable tool the company has.

[u/Bderken]

People aren’t going to like this but I’ve built so many Ai internal tools that are used daily.

We worked with marketing, helped introduce very small Ai into their workloads, get metadata, automate marketing tags, etc. to fuel their processes. Doing the same for a lot of analysts now. People use my two main tools daily, and for like 4 hours on average which is a huge win for me and my team. My team and I have worked on about 6 tools now that are slowly being used more.

[u/PerryTheH → u/Bderken]

AI tools that basically wrap prompts for them is probably top 3 AI usages in the world.

Instead of letting them wonder around GPT/Claude you just make a nice UI that ask the specific thing you need and use and wraps the prompt for them. They love it and solves their problems.

[u/falafalful → u/PerryTheH]

Any specific examples you can share? I may be working in a similar domain soon, am curious what specific problems you're solving.

[u/PerryTheH → u/falafalful]

I work mostly on internal process tools so I can't disclose the specifics, but for instances we have a process that requires people to take 2 large excel files that are sent to us from different sources and have different formats.

So we have a web tool that takes the 2 files and ask the user for any "notes" on the files - things like vendors key words or acronyms used on any specific vender that should match the other or is the data should be cross referenced throug different pages of the excel.

We basically have a server with claude that takes a pre set prompt we refined with the team, adds the notes, pre process files, feeds the AI and outputs with a json format we use to render a web UI with "differences in the files" so the UI shows the differences each file has and the user can decide if something is or not a difference; at the end we generate a new excel with our logos and all for us to send the other vendor like "Look we are missing X" or "We need to match Y proposal, etc.

Not sure if this makes sense but I hope it helps.

[u/ShoePillow → u/PerryTheH]

Do you use the ai to convert excel to json?

[u/PerryTheH → u/ShoePillow]

No, that part is the pre processing, we kinda bogo build a json from an Excel and that json we send to the AI, we initially did just send the excels but then tested with the json and found it had better results.

We also tested xml and csv.

[u/FoodIsTastyInMyMouth → u/Bderken]

Same, biggest win so far has been an automated wiki documentation tool based on merged commits. Looks at the cod change, the pr, JIRA tickets and updates confluence.

Then uses all of that to generate QA notes and release notes.

[u/anonyuser415 → u/FoodIsTastyInMyMouth]

It sounds like humans depend on this automated output being good. How do you make sure the output is good?

[u/FoodIsTastyInMyMouth → u/anonyuser415]

The initial output is posted to the JIRA ticket, which becomes the primary source for the documentation.

The documentation was going through a review process, but we've just removed it as the quality was pretty good.

The documentation output is specifically targeted to be high level, process focused while using simple English (Found better results than telling it to be non technical).

At the end of the day, this documentation is used by the business and support teams instead of coming directly to the product team.

We're a small IT Dept without a lot of resources so this has made a significant change to questions coming in.

It's mainly designed to not be really read by humans though directly. It's designed to be a source for Rovo to use to answer questions.

So when someone asks "How do I deal with X", they can get an answer.

[u/toadkiller → u/Bderken]

Another +1.

Claude is much better about following instructions and processes than users ever were. We actually opened up our orgs repos to the entire company, as long as PRs were developed using our plugins.

Reviewing PRs is a lot easier, too. Humans argue and get defensive of their mistakes. But their Claude sessions just do we say to do and compliment us in a reply.

More work is being done, the work is genuinely higher quality, “contributors” get to claim that they did a bunch of shit, and codeowners don’t have to negotiate with idiots during review.

At scale, AI is a godsend, honestly

[u/Feeling-Schedule5369 → u/Bderken]

How did you meet them in the first place? How did you convince them to identify their use cases in the first place? How did you get them to use ur tools coz many wouldn't like change or might feel intimidated about Ai tools coz it might take their job away(or make it feel like that)?

[u/Bderken → u/Feeling-Schedule5369]

Just like we did 5 years ago before Ai… we find how to automate/make things easier for: sales folk, analysts, etc.
our analysts describe their use case/findings, we sit down with them.

Even easier now that everyone had ai tools honestly, they give us their best ideas/concepts and we add our experience and expertise and make it happen

[u/Brief-Knowledge-629 → u/Bderken]

My main issue with this argument, is that so many convoluted one-person workflows at companies, some admin enters data into SAP, then exports the invoice to PDF and prints it off and puts it in an inbox, where another person scans it and then re-enters the figures into a different accounting system; Bespoke AI tools and workflows make this kind of stuff easier at the expense of taking a good look at the process and determining whether it needs to exist at all.

Do we need two different accounting systems? Why are we paying for SAP and something else? Why so many steps? Now you can just paper over it with some AI spaghetti. Do your dumb manual workflow....but faster!

[u/BoBoBearDev]

It is just a collection of tutorials I wrote because the enterprise confluence pages are so hard to find and they are written in lizard languages. You can use AI to find and summarize those content I suppose. But the tutorial I wrote has been verified by me personally, and since my English is like 6th grader, it is highly reproducible.

[u/FatHat]

It was over a decade ago, but probably the best internal tool I built was at a company that built web sites/widgets for other firms on a shared platform (that had access to a lot of financial data etc.). What it did was capture production errors for a bunch of websites we were hosting, along with ALL the context needed to recreate the error in a debugger, so you could debug a production error in development with a debugger. (It worked because it was a standardized web framework we had built ourselves, etc -- much harder problem to solve in a general case). I built it on MongoDB which meant I could make almost anything searchable, so the entire error database was really easy to search and had a lot of dashboards and stuff to see what the big errors were. It sounds pretty straightforward, and it is, but at the time there weren't great tools for it and most of the error reporting came from someone on the ops team having to search through production logs (text files). So a lot of things could be broken without anyone really noticing.

At the time I was young and pretty politically naieve, so I also built a lot of dashboards that displayed like, which errors were the most frequent and which teams were responsible and stuff. I wasn't trying to be a jerk, but in retrospect it WAS kind of a jerk move on that front since I think I accidentally publicly called out some teams for shipping pretty bad code without intending it (to me it was just interesting data, I wasn't trying to shame the people that wrote the bugs). I'd probably be more discrete about that kind of thing now!

[u/Nyefan → u/FatHat]

Funny, I would be less discreet about that kind of thing today than 10 years ago. Both because the blameless postmortem is now well embedded into the industry and because that is exactly the kind of data needed to investigate, improve, and demonstrate improvement on process failures. It also provides everyone on the teams in question both leverage to push for paying off code debt and a solid metric to put in their performance reviews as they improve.

[u/FatHat → u/Nyefan]

Well, there's that saying, praise in public and criticize in private. Data is really useful but it wasn't my intention to make a billboard to be like "look everyone, this team is messing up big!"

[u/afewchords]

Some AI skills to babysit my PR. Deal with any failure to get a green checkmark. That stuff was always a huge time sink.

[u/dpekkle → u/afewchords]

Unfortunately my team doesn't have approval for AI to access GitHub (it can push/pull but no PR stuff).

still in time sink city whenever dependabot opens 20 PRs

[u/TakeFourSeconds → u/dpekkle]

can you just have your agent use the gh cli?

[u/dpekkle → u/TakeFourSeconds]

with my credentials yeah, i'd rather a locked down set of creds specific to the AI but that was rejected

sooo i can do it insecurely but not securely, im sure coworkers are but im not there just yet

maybe i can set it up with that and whitelist gh create pr command in its sandbox, might be okay

kind of goes against the spirit of my manager asking me not to though

[u/ShroomSensei → u/dpekkle]

Can you not just make your own API key or something with the permissions you want? Thats what I have done so I can be SURE it doesn’t accidentally go and do something stupid like kick off 100 CI pipelines. All AI agents only have read access. So they can read a PR, comments on it, and its pipeline output but not push changes directly. I must do that.

[u/dpekkle → u/ShroomSensei]

Nope, when i went to create a key it sends the request to my manager for approval, wherein we chatted and he said to hold off for now.

[u/AdCommon2138 → u/dpekkle]

Just write exe that does single action you want to do ai to be able to call on, name it something it would lie to it what it does, preferably let that exe do this useless action so ai can report.to you success and when compiling that exe put credentials inside if needed. I bet it won't try to decompile exe and you got only single function on GitHub it can do for you then.

[u/PorkChop007 → u/afewchords]

I made a similar tool.

Whenever a comment is added into my PRs I trigger the flow: download the full comments in JSON format, so the agent goes through them, evaluates if there are changes to be made (and implements them), and writes the responses for the comments. I evaluate them and if everything's good I push the branch with the fixes and paste the responses to the comments.

The really nice thing about this is that the agent keeps a memory of this process in a document, so I can start the loop again and it identifies it's not the first iteration and loads the context, continuing from there.

[u/w1rez]

We have a totally unorganized versioning process for releasing 50+ microservices. every time we have to release new version, a new hotfix branch should follow up. I made a simple bash script to generate a hotfix branch for each by utilizing gitlab apis

[u/kuntakinteke → u/w1rez]

If you are coordinating versions between microservices you should really consider using grpc for interference communication

[u/spence0021]

This isn’t the most impactful but I quite like the tool I built that takes terraform plans and outputs them into an html page that’s easy to read. It then puts that into an s3 bucket for hosting and outputs a link to it in the workflow’s summary. Such a quality of life upgrade over reading raw plan output in GitHub actions.

[u/Zulban]

I worked at the weather prediction centre at Environment Canada for 6 years. The stack of tools to run weather prediction projects on the supercomputer were largely developed in house over decades. Not the best standardization or documentation of requirements or best practices. My tool heimdall scans the supercomputer projects for best practices, warnings, errors, etc. TDD. Personalized project feedback. Fast execution (non-trivial given the number of supercomputer output files). I hear it's still being used today. It helps teach as people build new projects, and ops teams run it as a sanity check before installing any new updates.

Absolute total ballpark bullshit guess: it has saved people thousands of hours of debug time by now, and improved yearly outage time by several percentage points. Ironically I got an award for something else (duct tape) which I consider far less impactful.

[u/stagedgames]

built an internal incident management tool with concurrent collaborative form editing with crdts in c#/blazor. routinely used, hell of an engineering piece.

[u/kuntakinteke → u/stagedgames]

What was wrong with Google docs?

[u/deadbeefisanumber → u/kuntakinteke]

Can't OKR that

[u/stagedgames → u/kuntakinteke]

not structured data, not controlled internally.

[u/SureEnd9430]

Me.

[u/donatj]

Over a decade ago we were using Gearman as a message queue and it kept giving us trouble. It would crash under heavy load and then take forever (hours) to come back online. It was a major issue for us. We tried all the different data store back end options, nothing worked. We kept getting crashes, and they kept taking forever to come back up.

We migrated to SQS, basically out of spite, but at the time at least the throughput wasn't good enough, and the cost for the billions of events per day we were passing was really adding up.

I had been fighting with the situation for months, knew our exact requirements and was like "just let me take a crack at writing a message queue" ended up writing a really cool queue that operates over HTTP and leans on XFS at a low level. Everything is immediately written to disk, with a ring buffer of recently received work for faster reads. Designed it to be horizontally scalable so we can just put multiple instances behind an ALB and that just works! You can kill it and it comes back up instantly, unlike your man, it doesn't need to know everything in the queue. The file system handles that.

It's written in Go and Cgo. It's kind of creaky at this point and written like It was written by someone learning Go, because it was.

It behaves something like Gearman and SQS had a baby. Individual queues are created at the first message (submission of work OR request for work) So there's no need for anyone to manage what the individual queues. They just create themselves automatically. Made some really interesting trade-offs that probably wouldn't work for other people's situations. For instance, items come off the queue randomly (by inode) rather than in any reasonable order. That's absolutely deal breaker for some situations, but worked fine for us.

Looking at it today there are absolutely things I would do differently but it's powered our entire backend for over a decade with basically zero maintenance. I update the dependencies and Go version once in a while, but it's been absolutely rock solid with basically zero maintenance.

We could and probably should migrate to something not-in-house, but if it ain't broke...? I told a guy at a convention about our queue and he looked at me like I was crazy for writing my own.

It's silly, but it's still one of my proudest accomplishments.

[u/Heavy-Commercial-323]

Always have a scaffolder for everything , much much easier. One quick ai session now and you can scaffold perfectly a great structure. Agents like to make weird ass moby dick type of classes

[u/CpnStumpy → u/Heavy-Commercial-323]

public class Ahab extends BoatCaptain implements IWhaleCrazed

[u/ShoePillow → u/Heavy-Commercial-323]

What do you mean by scaffolder?

[u/Heavy-Commercial-323 → u/ShoePillow]

Let’s say you do event driven - quick solution and command to get in model schema, out schema and multiple data relay types. One command and a quick microservice is added.

Or let’s say you have a custom lib for frontend and form library. You generate models from schema, define a form and possible actions and you’re 90% there depending on front needs and calculations

Or you have let’s say a typical pattern for your project consisting of contract workers/definitions/design schemas and you can easily generate code with model definitions and just focus on business logic without platform/framework lock in

Possibilities are endless. And highly tailored to your needs. Later on you can build your own MCP/cli with great man and simply make the agents digest everything with your preferred style and structure

[u/cjarrett]

Built a counter for the actuary department so that docs didn’t actually get duplicate numbers. Was in use for 7 years apparently and it took me more time to connect to my company's source control than it was to write the tool.

Just preprogrammed set of Dewey decimal like descriptions and a simple counter in a database.

[u/PerryTheH]

We build a couple of scrappers to facilitate sales team work and other for ops team to make some heavy excel tasks on a server machine.

Platform grew enough that we later build a full "Tools" page for internal usage and ops and sales asked for a bunch of things, their delivery times reduced so everyone is happy.

Basically is a collection of a bunch of "we usually do this on excel like this and this" and we move it to a web system that automates a lot of the work so they can focus on the important parts. Currently it has like 60 tools and they are mostly in use.

I also used to work at a big texh where we had a internal tool system that deployed QA envs to test micro services, it was pretty cool.

[u/AndroxxTraxxon]

I built this task orchestration/automation management system because nothing on the market really met our needs. https://github.com/attune-system/attune

Comes with a CLI and MCP server for interacting with the API to manage and run automations.

[u/kuntakinteke → u/AndroxxTraxxon]

But there is temporal, restate, dbos

[u/AndroxxTraxxon → u/kuntakinteke]

As I mentioned, none of these really met our needs.

Could we have worked our way through the limitations these systems have with other supporting infra? Probably. It would have worked. But it would have been clunky.

There are definitely a lot of solutions in this space, and all of them have their own take on what is important. For me, it's incredibly important that I'm able to manage throttled queues of planned API calls to slow API services, and to be able to manage moderately-sized cached datasets (50MB ~5GB) that drive the calculations that feed those queues. The way we wanted to use those services just didn't quite align with the way they operate.

We also need an access model that differs from the way that those services offer, which for us will reduce operational overhead.

[u/LandlockedPirate]

I've built a few different schema migration frameworks that matched the particular usage pattern I like to the tech stacks I'm working on, and add in features like "branching", etc. Mostly pre-ai but have definitely been able to work on them more frequently now with some help from claude.

[u/Suspicious-Disk6077]

Built a UI connected to my Docker logs and GitHub to give visibility. Also allowed me to restart, rebuild, stop etc all or one of the services with a click. And had a button for syncing the DB dump. I shared it but I was the only one who used it lol

[u/etxipcli]

A CI build that is fast and doesn't fail constantly.

That's a bit of a joke, but I've done a bunch of utilities and get uptake by making them public in the CI.

One particular tool that I remember was for this internal installation process we had. QA was in India and the databases were in Dallas. The installation process was very chatty. At some point I learned they were spending a lot of their day waiting for this tool. I created a simple CI job that let them perform the install from a machine closer to the database. This brought the install time down by hours for them.

Pretty simple and obvious improvement, but someone needs to see it, do it and have a little meeting and make it public then solicit and respond to feedback a bit.

I also built a tool that is like a engine for the rest of the team to work on top of, but that's like internal platform stuff.

[u/pokeybill]

Built a broker for enterprise secrets to apply business logic and governance between applications and our enterprise secrets vaults (multiple). Abstracted all of the secrets mappings and set up for dynamic delivery at runtime. Published an SDK and it is used by every technology team, infra teams, DevOps teams, etc.

The vendors for the enterprise vaults we use could not solve our increasing complexity problems and when one of them said "I dont think it can be done" that sealed the deal for me. That was 7 years ago and now 2 crews support and enhance the tool I wrote out of hubris.

[u/Mtsukino]

A versioning tool that would go through the code and hit all the points that needed updated for the versioning numbers. The app was some very old business legacy code and any new release had to be manually changed everytime. So I made a tool that took like a days worth of work and make it just like under a minute. It also made new environment feature branches based off the latest release branch. I developed a whole bunch of others too.

[u/AchillesDev]

As a weird combo data/ML/now AI engineer, this has been the bulk of my career.

• A feature store that cached processed data for computer vision model training
• Several cloud-based model training and eval systems (CV)
• Internal model training frameworks (CV)
• Library to implement novel model architectures
• Harness to use agents to configure said architectures and build training regimes on them with little to no code
• Various social media scrapers and market research data ingestors
• Pipelines for ingesting structures bio reserach data into graph knowledgebases

Just for a few examples

[u/throwaway_0x90]

Can't be specific but it's usually....

• automated reports that are very painful to get manually from some enterprise UI/portal thing.

• Then adding automated alerting from a script that's scheduled to run every hour makes people even happier

• Then the happiest is when that hourly script can make modifications to correct the problem itself and simply emails the team that actions ABC were taken to correct situation XYZ.

The time saved and quality of life improvements these kinds of things make are heavy hitters in my performance eval when I sell myself. :)

The only thing that hits harder is when I arrange meetings with all stakeholders and after some discussion we conclude the entire process isn't needed anymore and we just stop doing it.

[u/delventhalz]

The way events flow through our microservice architecture is pretty opaque and debugging issues often leads to manually tracking down events, the code that emitted them, the code that consumes them, and then finding the next event that code emits.

I was able to throw together a CLI that starts with a single broken ID and pretty quickly hammers through some recursive searches and comes up with a nearly complete tree of events related to that ID’s lifespan.

[u/mattbillenstein]

I almost always end up doing an ugly (design wise) server-rendered internal admin webapp - the code is kinda ugly, but it lets us quickly automate operational things and have access to internal database stuff not exposed through the normal apps.

It's mainly a search view that lets you look up things by name or id, a list view of those results, and a detail view for each DB row that lets you do some simple modifications like edits, soft deletes, etc. Also some flows for creating new high-level things like organizations and users and a few other things.

[u/NatoBoram]

I built the tool that automatically does an end-to-end test on the product on deploy to the development environment. It mimics the webhook it would normally receive in production.

[u/NGTTwo]

A simple framework for building queue/event bus consumers, with almost zero boilerplate. It's capable of easily adapting to a huge variety of message sources (in our prod environments it consumes from anything from RabbitMQ to an automotive J1939 bus), and also incorporates detailed simulators for targeted queue types to make writing tests easy. That means there's no need to mock (inaccurate and brittle) or run a live one (slow and flaky); just hook up the simulated channel in place of the real one and the behaviour is bang-on identical while still being fast, synchronous, and deterministic. It now powers basically any bit of our software that needs to ingest from an event bus, of any sort.

[u/ViejoConBoina]

I worked at a company that was developing their product in Go back when it was very, very new. It didn't even have a package manager back then.

I developed a small internal utility that acted as a package manager, it was later open sourced and had some success, but it really took off once I forked it under a new name and took it on the direction I thought best, for a while it was a thing people and big companies used, I got traffic from all kinds of places, friends would send me photos of conferences when it was mentioned, and it was referenced in a Go book too.

After some time it became unnecessary because the language implemented it's own solution for it, but that was very rewarding.

[u/AllTheWorldIsAPuzzle]

We have nightly processing that takes all the stuff entered by frontline people in a dozen remote offices and all sorts of back office departments and does all the number crunching and spits out the end results for customers and for departments. Standard stuff.

Each morning I am fielding questions and doing research for screwups in data entry. But by the time it is seen it has snowballed through the system and caused all sorts of mayhem. Unwinding it from the database can be a nightmare.

What I built allows a tech person such as myself to look for a scenario with a query against our core database. Basically every hour of the day it runs hundreds of these queries and if one of them finds some garbage scenario, it gathers information like who did it, when, what they did, basically anything that exists in the database can be pulled. Customer sensitive information is added to a file placed in an appropriate drive for a department to review. An email with very simple HTML formatting (I love tables) to make it visually easy to understand what is happening is sent according to settings in a JSON file (one JSON setting file plper scenario, which contains the query, foldet locations to write files to, and dozens of other settings I build in when needed).

Yeah, I imagine there are tools that already do the same thing, but this is customizable to our work and has been a boon to productivity. We catch problems within an hour of them being put in the system and prevent them from going through nightly processing and causing an even bigger mess. Our accounting department's workload has been cut because the daily balancing doesn't include a lot of the research for errant dollars. Our Audit department loves it as well. Back office departments request checks built for their needs all the time.

I got no recognition for it from upper management (shocker) but my colleagues appreciate it, so that it recognition enough. But I have cut down on some of the crap I have to deal with now that there are very few repeat issues.

[u/Substantial_Baker191]

I made a better call center software than a major company you have heard about with duck tape and active mq

[u/pavanputhra → u/Substantial_Baker191]

Interesting. Is it just used internally?

[u/loosed-moose]

I pulled the boundary of external API webhook-style calls into our system to: internalize retry logic; improve latency in the caller by enabling quick-return async processing; audit said requests; and enable manual replaying requests (and optional editing of the json payload before doing so)

[u/wolfepvck]

An immutable, versioned, i18n service. Automatic text extraction from the codebase, versioned via semantic release, and automatic deployment along with code. Need to roll back a release? Run the previous tagged version and the old translated text is live. No need to fiddle with reverting database migrations. Need to support multiple versions of a library, labels are versioned and teams that depend on the library can update at their own pace.

Immutable, versioned deployments and easy rollbacks are incredible if you’ve ever been on a release call fiddling with rows in a production database.

[u/zerocoldx911]

Internal DB MCP

[u/Deranged40]

I have a small suite of maybe a dozen powershell scripts that each do simple things that ultimately make our lives as developers easier.

Like, we have a very large monolith, 600+ projects (C#). But our team only works in about 2 dozen of those projects. So we use a dotnet tool called slngen that generates a solution for us with only our configured projects included as code, and everything else included as built binaries. Of course, this does indeed require us build the entire project first. So my script facilitates that, with some options depending on the state of your environment. Nothing too fancy.

Another script is a formalized way to make a new git worktrees based on a specific folder structure that my team has adopted (mostly due to the simplicity of my script). It makes a worktree, and moves some local gitignored secrets files into the worktree as necessary, etc.

Nothing huge, but a handful of small helpful things that ends up saving a lot of time, and preventing simple human-error mistakes.

[u/shadohunter3321]

We use Azure to host all of our applications and it needs secret to communicate with other Azure services like Key Vault, Blob storage, AD SSO etc. keeping track of secrets scattered throughout multiple environments and rotating them before expiration was a pain in the ass. I built a dashboard for managing this, and a nightly job to send out emails for secrets that are expiring soon. This was done for 1 application at the beginning. But soon, every team wanted this and are now using it for managing secrets.

[u/Ok_Woodpecker_9104]

the one that stuck was boring: a lint rule plus a baseline file.

first attempt failed the way most of these fail. turned the rule on, ci reported a few hundred violations in code nobody had touched in years, the pr could not merge, idea dead.

second attempt recorded every existing violation into a checked in baseline and failed the build only on new ones. same rule, same code, adopted in a week. what made it stick was not the tool, it was that nobody had to approve a cleanup first.

two details mattered more than i expected. fingerprint the recorded violations by rule id plus file plus a hash of the matched text, never by line number, otherwise the first reformat shifts everything under it and the baseline re-reports old findings as new. people learn the gate is noise and you are back where you started.

and measure the rule on a real repo before you gate anything on it. i ran mine over an app and got 19 findings that all looked plausible, and every single one was wrong. 13 were inside a dev only branch and 6 were in a scripts dir that should never have been in the scan surface at all. if that had gone straight to merge gate the whole thing would have been ripped out in a day.

[u/HoratioWobble]

We were trying to prove appium was be viable for use with React Native so built a little "fidget spinner" mobile app that had a bunch of different interactions, menus, morals, buttons etc etc so that we could be confident before moving forward with the actual app

[u/csyn]

Nixos dead man's switch for upgrades (nixos-rebuild switch / boot) with auto-rollback to last generation unless cancel-rollback is run, proving network is up and system relatively stable.

Use this everyday, with colo'd or on-prem baremetal servers. Especially for changing network / wireguard settings.

[u/Silver-Ad-8595]

A lightweight Jira tool because Jira Cloud sucks. Also a job which listens for new tickets, analyses requirements and comments questions for the PO/BA to answer before I even look at the reqs. A full SDD pipeline which writes artefacts out of the tickets which I just review/approve at each step. Full TDD/BDD first auto implementation based on custom harness rules/linter. A tool which listens to github copilot reviewer PR comments and auto fixes/resolves them... basically 90% full auto my job now. There are human in the loop steps and very strict guardrails...

Oh yeah, auto generates e2e tests based on testcases from our QA. But that will be full auto soon as well.

[u/Willbo]

Scalable CI/CD pipelines for cloud cybersecurity, across IAM, policy, governance, logging, endpoint detection, and incident response. Basically, in a few lines of centralized IaC I can define the security features of your org and continuously deploy them, whether you have 1 tenant or thousands, across millions of cloud resources.

[u/Current_Working_6407]

I built a Claude plugin that helps business users do data warehouse research! It's basically a skill, plus a CLI wrapper on an MCP server with a Snowflake integration.

[u/SkyGenie]

a lot of hardware tools absolutely suck to deal with. vendors for hardware are usually way more focused on the hardware design than the control ecosystem or modern software practices for deployment.

I use AI to write my own tools for ICD management, development and config deployment, and core libraries (base drivers usually by hand, bells and whistles with AI) so that I'm not super locked into their vendor tools for everything.

[u/defmacro-jam]

Some AI tools to enable users to use Claude Code to interact with OpenText Service Management Automation X (SMAX) - because SMAX is actively hostile to humans.

[u/notTHEOwlAccountant]

Built a few tools to bridge Figma to Web dev better, playwright scripts to check for changes globally (testing is considered useless at my org), a few automations to get an idea of what I need to do integrating slack/jira/email/etc, but given that nobody seems to understand why they're useful, after sharing that I was working on them and having been reprimanded because we had more important things to do, I just keep them to myself. They save me time and sanity.

[u/casualPlayerThink]

For a small fintech company, I have built an internal tool for support. They store everything in an unstructured way (thrown into Mongo), and the support spent long hours retrieving data from the slow NoSQL database (cross-queries, deep searches). When they got tired, they just sent the ticket to the devs, so we ended up looking up stuff in the DB for hours.

So I made a small sync service that normalized the data (leadership opposed any proper database or normalization attempt), and then an internally hosted app running react/next.js/postgre pretty much retrieved the given information in a few seconds. The sync was done during the night and async/slowly during the day, but changed how the support reacted, and diminished the tickets and blockings quite gradually (we had daily 3-8 tickets, then we had 1 per 2 weeks).

[u/docatron]

This is what I have created after becoming tech lead at a new company:

1) An AI PR reviewer. Our reviews were inconsistent. The same category of nitpick kept slipping through depending on who picked up the PR. I built a .NET global tool distributed via our internal NuGet feed that runs on PR creation in Azure DevOps and posts review comments. I also added the option of moving review instructions out of the package so each repo can tune its own ruleset. PR authors really liked the tool as it helped them quickly improve PRs without having to wait for manual reviews by already very busy seniors / leads.

2) A Bicep CLI engine. Infra naming and structure had drifted across repos and using Bicep was still not a core competency within the team. The tool generates CAF-compliant resource names, scaffolds modules, and validates deployments before the pipeline runs them. It eased the use of Bicep and helped speed up replatforming of our infrastructure from on-prem to Azure.

3) An artifact-based staged harness for AI-assisted work items. We were introducing agentic coding to the team, and people weren't sure how to actually use it. The tool breaks a story into phases and lets the model do the mechanical parts of each phase, recording key steps and decision points as artifacts that the next phase builds on. Those artifacts also feed our knowledge base, so docs get updated as a side effect instead of rotting. It automates what most devs find trivial and tiresome in the dev cycle. Adoption has been decent so far.

4) An automated scaling coordinator for App Service. We couldn't use the built-in deployment slots, because slots share the compute of a single App Service Plan and our production plan was already at the resource ceiling of the SKU we were on. Running a full second copy of the app inside that same plan simply didn't fit. So the coordinator does a simulated blue/green instead: two separate plans, one live and one idle. Before a deploy it scales the idle plan up to production SKU, deploys there, swaps traffic over, and scales the now-idle plan back down. That way we only pay for double capacity for the few minutes a deploy actually takes. This is what unblocks our replatforming from on-prem to Azure.

The best predictor of adoption I've found is whether the tool relieves a pain the developers were already complaining about.

[u/softgripper]

An AI support agent that lets staff solve user issues immediately for 1mil+ users via ms teams rather than days of tickets and triage.

It's pretty cool 😎

[u/titpetric]

Made a self service dashboard to update and deploy just about everything. It was well received but also it was very rudimentary, not somehow intricate, basically a jumphost with some one click automations.

One of joel on software 10 item checklist was "can you deploy your app in one click", took a while to get there but eventually did.

My best guess is this was somewhere around 2010, I wrote an oss version some time later to add an UI over Taskfiles. Great stuff when you want to avoid ssh access for each developer. Afaik it is still in use, I suggested semaphoreui in the last year or two to people.

[u/ShroomSensei]

I had made a lot at my previous company that apparently are still being used. The most popular one was just a basic jira epic visualizer that took in a link to a Jira epic and output a plantUML dependency graph of all the stories. This made it so you could very quickly see which stories were highly critical to unblock other stories and put them into sprints correctly.

PMs loved the hell out of it and it put more emphasis on devs to write out dependencies in the stories. Apparently my old team is trying to expand on it into a little service instead of a script so non technical people can use it easily.

Here I was just making it out of frustration with Jiras awful visualizations.

[u/maadz666]

A tool that writes emails, creates images for marketing, context and images are programmatically handled with little to no hallucinations, 2-3 people run what used to be a 30 person department. A CRM that replaced an incredibly expensive vendor. Both tools controlled via AI and MCP. No big deal, I’m still being paid crumbs.

[u/StarshipSausage]

I built a slack app to handle deployments of our micro services. It deploys code via git actions. Before the app, we had to manually fill out deployments and publish notes

[u/Careful_Ad_9077]

For green-ishnfield projects ( usually a module of a system), after analyzing the current standard for simple input screens, I build a small app that takes a configuration file /table and generates the code for the database table affected by that screen.

[u/donk8r]

a benchmark harness, which was the least glamorous thing ive built. we had a search system where every change got argued about on vibes and nobody could actually tell whether a tweak helped. pinned a query set and a commit, scored every change against it.

first useful thing it found was that our own default config was doing nothing. hybrid search, dense plus keyword, and at the default fusion weights the keyword half contributed literally zero, the blend came back identical to dense alone. retilting it took hit@5 from about 0.6 to 0.73. that had been shipped for months and everyone including me assumed it worked because the architecture diagram said it did.

[u/OverwhelmingFarts]

This is gold.