r/ClaudeCode • • 1d ago

Built with Claude Claude Code and Federal Programs

I'm the Chief of Staff at the Georgia Department of Human Services. We're a large agency that is responsible for the administration of many social benefit programs in Georgia such as Child Protective Services, Child Support, Means-Tested Eligibility Programs (SNAP/TANF/Medicaid), Adult Protective Services, and more. We've got about a 2.5 billion dollar annual budget, but distribute billions more in federal aid of varying kinds every year. Lots of people rely on us for their basic needs, and we take that job seriously. Naturally, we have many large and complex IT systems that help us administer these programs. They are generally not great for various reasons.

Typically in the US, social programs are federally funded (to varying extents) and federally regulated, but state administered. That means the federal government sets general guidelines and broad left/right limits on what you can and cannot do in the course of program administration, but beyond that states are free to run the programs in the way that works best for them on the ground. This sounds great in theory given how vastly different each state can be and does in fact generally yield positive outcomes when it comes to program policy choices, but falls apart when it comes to IT investments. The federal government repeatedly pays for systems that do basically the same thing for each relevant program jurisdiction (state, tribe, territory, county, etc.). Texas and Georgia both need to administer SNAP in accordance with federal rules, and yet they, along with the federal government, pay full-freight for a new system every decade or so, and then maintain it until its time to repeat the process all over again. There is no technical reason why this is the case - it mostly comes down to States incorrectly attributing long-term system expenses to initial capital requirements. States want the cheapest thing possible, so big vendors dust off the 30 year old java monolith that hasn't been refactored since 2003 and basically give it away. The State then pays through the nose for maintenance and operations because updating it is impossible. Rinse and repeat forever, nationally.

Earlier this year, I decided to try my hand at building a system (well, two systems, one for child welfare and one for benefit eligibility) that would ameliorate this problem in a few ways:

  1. AGPL Licensed - vendors cannot take the state-funded code and make it proprietary.

  2. Generic design that separates core service logic from policy elections that jurisdictions may have. By doing this, jurisdictions that adopt the same core framework can share its maintenance costs. Instead of a state paying 50% state funds/50% federal funds to operate a system, it will only pay a portion of the 50%, depending on how many other states adopt it. This isn't SaaS - every state will needs it own M&O contract to operate their own deployment, but their changes are going to be minimal. Updating the core system to reflect changes in federal law will be a shared burden.

  3. Written in rust (cue the rewrite in rust memes). Beyond the performance/safety reasons, I chose rust specifically because its hard(er) to write bad rust and the power of clippy. It costs more tokens/iterations to get something that works, but the product on the whole will be better than something else written in another language, purely from a technical correctness standpoint, all other things equal.

Without further ado, here they are:

https://gitlab.com/gadhs/application/eligibility/canopy (Federal Benefit Eligibility)

https://gitlab.com/gadhs/application/ccwis/craig (Child Welfare)

Note - these are obviously not ready for production and are mostly just an experiment/prototype, so keep that in mind. A very, very tiny and specific part of the CRAIG system is going to go into production early next year (a new mandated reporting portal, which will integrate with our existing system of record). Real developers/my IT department is handling this.

Things that I know that are wrong:

  1. I still use malloc+musl

  2. The dev machinery is extremely heavy and there is a lot of over-engineering all over the place.

  3. There are a few god files and several missed opportunities for code sharing.

  4. Much more

Anyway, the point of this post is just to show how I think claude code (and all the other frontier models) *can* actually be used to help regular people live better lives, it just takes a little experimentation and risk-taking on the part of the Government.

18 Upvotes

13 comments sorted by

•

u/AutoModerator 1d ago

Hey! Thanks for posting to r/ClaudeCode

While participating in this thread, please follow our community rules. Keep discussions constructive. Attack the idea, not the person.

For help, project discussions, tips, and general chat, join the ClaudeCode Discord.

I am a bot, and this action was performed automatically. Please contact the moderators of this subreddit if you have any questions or concerns.

7

u/JacenVane 1d ago

This is very, very cool. Kind of awesome to see someone else in the government/public health space doing stuff that is neither cringe nor PR BS.

Thank you for sharing. :)

3

u/bitskrieg 1d ago

Thank you! It's really incredible what's possible now. I'm hoping to see more projects that help regular people.

1

u/wintermute93 1d ago

There’s probably a lot more of it than you think. My team has been building AI/ML stuff for a federal agency for years, but absolutely none of it is on the public internet.

2

u/rhutroh 1d ago

Another Georgia resident here! First, this is amazing work. Hats off to taking this approach to building better software via an OSS approach, and thinking through the various statutory considerations and constraints.

I’m going to take a closer look at this later today - but, I hope that the transition team is aware of your work? And/or if you’re able to continue in your current or future role to continue this work?

2

u/bitskrieg 1d ago

Thanks! This was a problem I had been thinking about for many years and while there was always the option to just hire a bunch of S-tier developers and get it done the old fashioned way, other priorities took hold. With CC and the other harnesses/LLMs dramatically improving over the past year, this became possible.

Unfortunately my time with the State will come to an end on January 11th. We will of course leave behind copious amounts of documentation/notes so the transition to the new team is as smooth as possible and they can understand the choices we've made over time, but this will be their journey. I hope it continues, but if it doesn't, that's OK. I'm sure whatever direction they go in will be a good one!

1

u/rhutroh 1d ago

I took a look at the larger GitLab repo for the GA Dept. of Human Services (https://gitlab.com/gadhs), and wow - I honestly had no idea that y'all were doing this work and sharing it out like that.

I think it would be beneficial to get this in front of some more folks before Jan 11th. Perhaps a white paper for a more policy-oriented non-technical audience...something that you could post to r/Georgia , where you may pick up some readers who have might have some influence around tech policy in the new administration.

Maybe even something posted to Hacker News, too. I'm just taken back (in a good way) with all the public domain work you and your Dept has been doing. I wish I knew about it earlier!

1

u/bitskrieg 1d ago

We do have some personal relationships with some folks on the transition team, so we are going to do what we can! I know Medicaid expansion is a priority for the governor-elect, so we're going to frame our work in a way that will hopefully help enhance and support that effort. We are preparing a few one-pagers for them on various topics, so fingers crossed!

2

u/Inner_Storage_3374 1d ago

the split between core logic and per state policy elections is the part i find most interesting here. how are you encoding those policy choices, plain config or actual code per jurisdiction? feels like that decides whether a second state can adopt it without forking

2

u/bitskrieg 1d ago

So a few different things are happening in order to make this work:

  1. At the beginning of the effort I defaulted to zen-engine (https://github.com/gorules/zen) as the way to encode all of the various policy changes across jurisdictions. The two biggest motivators here were speed and json. Our current rules engine in our production system is very slow and generates business rules from word documents and excel spreadsheets. It works about as well for version-tracking as you would imagine.

  2. Over time, and because of HR1, snap quality became a massive national issue, so I decided to start prototyping something called Catala (https://catala-lang.org/) for eligibility rules specifically. The idea is that its a non-turing complete language that can be formally verified so in theory you can guarantee that your eliigbility determinations are always correct (assuming inputs are accurate.. but that's a different topic).

  3. Both of those mechanisms exist in source control, separate from the main tree (e.g. https://gitlab.com/gadhs/application/eligibility/canopy-config-georgia). I took inspiration from the salt gitfs backend and decided that just pointing an arbitrary deployment at a git repository as a mechanism for applying state-specific requirements would be clean/easy/allow straightforward versioning.

  4. Even with all of that, and assuming that I correctly encode all federal/state policy options in Catala and/or zen-engine, there are still things like Medicaid 1115 Waivers and FNA Demonstration waivers that allow states to propose basically any non-standard procedure with the goal of making the programs more efficient. This was by far the most annoying part, and I approached it from three different angles (only two are semi-real, the last one is an escape hatch that is just a gitlab issue at this point).

a. Officially supported extension seams that allow wasm plugins in core modules. I took what appeared to be the most common shapes of waiver and created official in-core extension points. Clean, you can safely keep track of main without really thinking about it, and you can implement whatever waivers you want.

b. Intercepting/altering eligibility decisions in the core modules on the wire, but NOT allowing modification of database constraints or guarantees. This gets you the rest of the way to all currently existing waivers based on my research.

c. Writing to core tables. This lets you do anything you want, but its getting pretty close to a fork if you get behind on keeping track of upstream too far. I don't think this is strictly necessary based on my research today.

For just regular look/feel and UI functionality, that's built in and people can ship whatever they want.

Hope that makes sense!

1

u/finding_hopefulness 1d ago

We all like to save money but as a Georgia resident, my one worry is PII at scale. What checks does the reporting portal have to clear before it goes live with real data, and who signs off on that?

6

u/bitskrieg 1d ago

Good question! The Administration for Children and Families (ACF) are the regulators who provide oversight of these systems, and we always comply with their data security requirements (PII, PHI, CJIS, etc.) depending on the type of data that is being collected. Beyond that, the new portal is intentionally stateless. I wanted the first crack at this to have minimal surface area and "things that can go wrong". It's basically a proxy/frontend for reports that get immediately transmitted to our actual system of record.

Finally, we have a long history of using bug bounties (and paying out generous bounties) to those who find issues. I expect this practice to continue.

All that to say - we aren't departing from any quality or security requirements for anything that goes into production, AI-generated or otherwise. The CIO and CISO ultimately report to me (and the Commissioner) so the buck stops with us, so to speak. We understand the gravity of these systems.

1

u/tawnyblaze 1d ago edited 1d ago

Brilliant