patrickdevivo

Repo that tracks Git commits with a coding agent "signature" in public GitHub repos.

thanks for sharing. some of the highlights we found interesting:

* Growth rate of new repos doubled in 2025 (driven by AI?) * Microsoft leads Big Tech in repo creation, contrary to narrative the company is closed * a16z captured nearly as much OSS value as all other early-stage VCs combined

Also, AI repos since 2023 have seen an outsized share of attention relative to other categories of repo (as measured by GitHub stars). This is not surprising, but interesting to see it playing out in the data.

I've been meaning to build a Stripe app to experiment with their UI SDK, which allows you to extend the Stripe dashboard interface with custom code. I took a go at it with a Customer Enrichment app: https://marketplace.stripe.com/apps/hybound-enrichment and got a couple of installs!

I just developed and launched my first Stripe "dashboard app" (https://docs.stripe.com/stripe-apps) - which is a way Stripe allows developers to embed custom UIs in the Stripe dashboard and distribute through an app marketplace. I thought this was pretty cool, so I wanted to give it a shot.

The app helps you understand your customers by automatically researching firmographic information and recent news about the companies buying your product - if the customer uses a work email. It uses the new OpenAI Responses API to do the research - so results are not always correct, but working on it! This is especially true for smaller companies that may not have much public information available.

It's basic for now - but it allows you to answer simple questions about who's buying your product, and gives you a starting point to find out more about them.

The app is free, and I have more features planned, including aggregate reporting over all customers, to answer deeper questions like:

* What industries do our best customers come from? * Do we sell more to large companies or small companies? * What's our ICP? * What's the geographic breakdown of our customers this month?

etc...

I'd love to know what people think - I'm open to feedback and would love to tailor the next set of features based on specific requests. So please let me know if there are workflows or insights you'd like to be able to see using this information. Thanks!

This is such a cool tool. It's a better approach to solving many of the questions I built MergeStat to answer (https://github.com/mergestat/mergestat-lite). It's been some time, but I also wrote a `git blame ...` parser in Go: https://github.com/mergestat/gitutils/blob/main/blame/blame.... :)

Amazing work and excited to dig into this more thoroughly

I've been using GitHub Issues (and their new Projects feature) more and more. It's far from perfect, but I really value the colocation of code + task management it allows. I like being able to reference issues/PRs by # in markdown comments - it feels more natural to leave "breadcrumbs" this way so that others can follow the chain of events when trying to piece something together.

One thing we've done internally, for all tasks that aren't tied to a repo (because GitHub issues must belong to a repo), we created an "internal" repo that's a catchall for tasks not necessarily tied to a codebase.

The Projects view then let's us plan work across multiple codebases and this "non-codebase" repo

a very cool project they also maintain is a MySQL server framework for arbitrary backends (in Go): https://github.com/dolthub/go-mysql-server

You can define a "virtual" table (schema, how to retrieve rows/columns) and then a MySQL client can connect and execute arbitrary queries on your table (which could just be an API or other source)

Seconded for Hasura - really great tool that's make it easy to setup an API on your database. Also makes it easy to manage your data models and permissions. You can use it to build REST API endpoints as well as GraphQL ones.

Thanks for this write up! I've been really interested in postgres compatibility in the context of a tool I maintain (https://github.com/mergestat/mergestat) that uses SQLite. I've been looking for a way to expose the SQLite capabilities over a more commonly used wire-protocol like postgres (or mysql) so that existing BI and visualization tools can access the data.

This project is an interesting one: https://github.com/dolthub/go-mysql-server that provides a MySQL interface (wire and SQL) to arbitrary "backends" implemented in go.

It's really interesting how compatibility with existing protocols has become an important feature of new databases - there's so much existing tooling that already speaks postgres (or mysql), being able to leverage that is a huge advantage IMO

This inspired me to publish a short blog post: https://docs.mergestat.com/blog/2022/01/01/a-year-in-commits

Counting commits, as mentioned, isn't particularly useful as an independent/absolute number - but I think it's an interesting way to see a high level "amount of contribution" relative to other contributors in a codebase. Of course, "commits" as a unit are not normalized, so this is problematic if you're trying to derive some deeper conclusion from counting commits IMO

this looks awesome! two things I've always wanted and haven't found satisfying solutions for in code search (in an editor)

1) an ability to easily express higher level concepts in a search that's aware of code semantics ("match only function names", "find call sites of a method") etc. Maybe this is possible with existing tools (probably is?) but I tend to get lazy about learning DSLs - would love to see this in a UI if it's possible

2) ability to save searches I do frequently - after a certain level of complexity in a query (I've added ignore rules, I crafted the right regex, etc), I want to be able to save the "context" of a search so that I can easily return to it later

Assuming committers adhere to it, there could be some interesting use cases when combined with a tool like AskGit (https://github.com/askgitdev/askgit) for understanding what "categories" of work is being done in a codebase.

Maybe even what directories/files tend to see `fix` or `refactor` more frequently (signs of a poorly design or "hot" area?)

This post inspired me to try writing some SQL that downloads all the LICENSE files of declared go mod dependencies: https://askgit.substack.com/p/query-for-go-dependency-licens... using a project I maintain.

Some flaws, but was able to download a bunch of licenses :)

This sounds similar to a proof-of-concept project I've been putting together for simila ruse cases: https://github.com/augmentable-dev/flite. Basically UDFs + virtual tables (table-valued functions) that are smaller helpers for using SQLite to slice and dice shell output. Still totally WIP, but I'm curious to play it out and see where it goes

I've been very curious to explore this type of use case with askgit (https://github.com/augmentable-dev/askgit) which was designed for running simple "slice and dice" queries and aggregations on git history (and change stats) for basic analytical purposes. I've been curious about how this could be applied to a small text+git based "db". Say, for a regular json or CSV dumps.

This also reminds me of Dolt: https://github.com/dolthub/dolt which I believe has been on HN a couple times

This looks awesome! Seems like a great idea - I'm curious - do you download the full calendar first into a SQLite DB file and then let a user execute queries? SQLite has a "virtual table" feature: https://www3.sqlite.org/vtab.html that could allow "live" queries against the calendar APIs, though my guess is that would be too slow to make sense.

The same query, but but outputting an ASCII bar chart: https://bit.ly/3bcElz4

cool! this could probably be coupled with https://try.askgit.com/ to do some simple slicing and dicing queries on the response time history in git (average over a time period, count incidents in a time period, etc)

nice! this is awesome! you mention in the README

the goal is to be able to expose more powerful planning optimizations, and simpler code.

an aspect of the sqlite virtual table feature (which askgit uses) is the ability to define "indexes" to avoid full "table scans" when the query is executed - depending on WHERE clause constraints.

I've seen calcite and would love to try it out! I just haven't written much java lately

The same query is pretty interesting for the kubernetes source code too: https://bit.ly/3tDgbXd

creator here - sorry about that, the code enforcing the repo size limit has been a bit buggy. I'm likely going to remove that soon

Fully agree with you here. I remember it being drilled into my head in middle school science class that "correlation does not imply causation," which seems to have been forgotten or ignored when writing these headlines.

This is really cool, and coupled with a tool like https://github.com/augmentable-dev/askgit, could yield some interesting results. It could produce a table of specific values/text changing over time, measure frequency of changes, etc

I'm the creator of AskGit - and this is something I've been thinking a bit about, unsure of the best way to implement and very open to ideas! Adding language specific analysis (this line is a comment, this is a function name, etc) is really interesting to me and I think could really kick this tool up a notch (there are still some more fundamental needs I'd like to address though, such as diffs and blames, query performance, etc).

I've been considering leveraging the syntax highlighting implementation in editors to make this possible (rather than something as heavy handed as parsing a "universal" AST, though I know there are projects to do this)...

haha you're totally right! if it's just a matter of renaming the binary and dropping it in a particular directory to get git to know about it, I can leave this part up to the user. I'll definitely have to make a note in the README.

gitqlite is a little clunky for a name, but I wanted to make sure to convey that it's sqlite doing a lot of the heavy lifting here!

At the moment, not easily, but someone else just asked about that and I think it's worth looking into! It makes sense and could be a cool use case to run queries on all the key repos in an org or project

that’s great to know, will take a look and add a note to the README

Creator here! Thanks for submitting - I hope people find this interesting. I’m excited to explore more use cases beyond listing and reformatting git log output! There’s a similar project called gitbase, but I had difficulty just spinning that up for ad-hoc CLI querying so created this project in hope of a better UX for that type of use case. It uses SQLite virtual tables, which was something I had been meaning to play around with. This seemed like a cool use of them!

I agree that trust is fundamental to tools/metrics like this, and will determine how they're used. What I find interesting (concerning?) is that they seem to be marketed towards managers/VPs/CTOs exclusively (people "outside" the team) to better understand what's going on within the team, which seems flawed (but also makes sense, considering who's making buying decisions). I understand the value proposition of "getting the most" out of your (expensive) engineering team, but presenting a product in this way seems to set the stage for "misuse" right off the bat. Maybe I'm biased, but it feels like these tools might be more palatable if framed to help ICs improve and understand their own behaviors within a team

I'm working a lot on https://www.tickgit.com, which is a glorified TODO comment finder for developers, to help us do simple project management in code.

It identifies code markers such as TODO, FIXME, HACK, XXX, etc (soon to be customizable) and surfaces them as cards in a web UI. There's a free and open-source CLI as well.

The web app is free for public repos and $3/month for private ones. I'm looking to add organization/team-based pricing soon too.

A feature that I'm hoping will have an impact will be a "TODO reminder" email that will email you within a configurable amount of time after a TODO is added to a codebase.

Right now it's just me working on it outside of the day job, I'm hoping I can turn it into a useful tool for developers!