DocIt

Writing docs is a waste of time. Keeping them updated is impossible. So we built an AI to do it for you: ⚡️ Push a commit 🧠 DocIt analyzes the diff 📝 Docs, APIs & runbooks update automatically Beta waitlist: whitelist.docit.in

@buildinpublic Bulletproofing the backend architecture for @DocItHQ so we survive our upcoming Hacker News launch. We built an autonomous agent that updates company wikis from PR diffs, and we need to make sure it doesn't hallucinate before the senior devs rip it apart. 😅

What are you working on this week?

@theo Running an autonomous background agent means we eat the inference costs on every single PR merge. GPT-5.4 pricing is basically extending our runway right now. The cost gap is getting impossible to justify for heavy context ingestion.

It is really funny to me that Sonnet is still more expensive than GPT-5.4

@heyblake For every dev who hates manually updating the team wiki after merging a PR. 🙋‍♂️ ​DocIt reads your git diffs and writes the documentation for you in the background. Whitelist.docit.in

Drop your project URL Let’s drive some traffic

@levie Aaron is 100% right. The best developer tools of the future have zero UI. We built DocIt on this exact thesis: a headless background agent that reads PR diffs and uses APIs to auto-write your Notion wikis. No browser required, just chores done.

Agents are going to use software 100X more than people will in the future. As a result, enterprise platforms will become headless and be able to work with any agent on or off platform. If you don’t do that you’re DOA. What some have missed is that this creates vastly more use-cases for these platforms than even existed pre-AI. This isn’t zero sum. Software value props have traditionally been capped at the number of users you have in a company. Agents have no upper limit. We’re going to run agents to process data at a scale humans never could, they’re going to be running 24/7 in parallel doing work for us, and they can integrate workflows across systems to generate all new value propositions. Once you embrace this approach, it becomes obvious how much more upside there is.

@mattpocockuk Option 1 from the thumbnail: AI Coding Agent! But specifically, an agent that listens to GitHub webhooks, reads PR diffs, and auto-updates Notion docs. The ultimate dev chore-killer.

I've got a rare slow day so I'm going live in 5 - Ask me your AI coding questions - Help me choose my next project - Let me show you my new skills youtube.com/live/K-mA3MZ_E…

@thdxr Doing fewer stupid things' is the ultimate engineering hack. We applied the same logic to dev workflows. Manually translating a git diff into a Notion wiki is a stupid thing. We built an agent to do it automatically. Instant velocity boost.

in the past week we've improved opencode's startup time by 2.3x not by doing anything smart, just by doing fewer stupid things it's still not amazing so will keep chipping away

@gumroad Code is equity. The more time you spend building the product (and less time doing chores like manually updating the project's documentation), the more you actually own. Let agents do the chores.

Followers are rented. Products are owned.

@denicmarko For every dev who hates manually updating the team wiki after merging a PR. 🙋‍♂️ ​DocIt reads your git diffs and writes the documentation for you in the background. whitelist.docit.in

Share your websites.

@peer_rich 10,000 PRs is insane. If updating docs takes just 10 mins per PR, that’s 1,600+ hours spent just writing documentation. 🤯 This scale of pain is exactly why we're building DocIt to auto-document PRs. Huge congrats!

contrary to popular belief, cal.diy, our free MIT project is still actively maintained and just merged its 10,000 PR

@delveroin Building DocIt so devs can actually enjoy their weekend. 🍻 ​You merge the PR, our agent auto-updates the Notion/Confluence wiki in the background, and you go home. No more manual docs. ​whitelist.docit.in

Hey founders!! It’s the weekend Share what you’ve built

@mattpocockuk An autonomous agent that reads PR diffs and auto-updates a Notion wiki. It’s a massive dev pain point, heavy backend (webhooks, LLM parsing), needs a clean dashboard, and watching you build the TS architecture for it would be a masterclass.

I want to do more 'watch me work' longform content. BUT I don't want to have to introduce people to the project every time. I want a single project idea that I can ONLY work on inside the video series. So, I need a project idea. It should be: - Useful in my everyday work (as a dev/content creator) - Have some frontend and backend component - Have a decent amount of complexity Hit me

@kiwicopple @ssougou @andy_pavlo The part about agents thriving in a clean codebase is so true. We see this building DocIt, if the PR diffs are clean, background agents can perfectly document the architecture. Messy code breaks AI. Congrats on the launch, T3 Code looks incredible!

this week @ssougou joined @andy_pavlo to talk about Multigres - a couple of database legends going deep on consensus the talk is part of the "PostgreSQL vs. The World" Seminar Series by CMU on youtube the intro song is amazing:

@theo The part about agents thriving in a clean codebase is so true. We see this building DocIt, if the PR diffs are clean, background agents can perfectly document the architecture. Messy code breaks AI. Congrats on the launch, T3 Code looks incredible!

Going to start talking a lot more about T3 Code. I hate shilling my own stuff. I really do. But I’m so tired of feeling the tools I rely on slowly eroding under me. That’s why we open sourced it. T3 Code exists because we were unhappy as a team. We tried every option and wanted something better. T3 Code is deeply open at its very core. We’re hiding NOTHING. Julius has been meticulous with the scaffolding and the codebase is a dream for any agent to work in. I’ve learned so much just reading through his PRs. I know devs who improved their own codebases just by showing them one of his diffs. T3 Code is built to be trusted. Even if you don’t trust us to get it right, you can trust the community, the code, and your own agents to make it work exactly how you want. It’s time to stop relying on tools you can’t change to fit your needs. T3 Code is going to be the most malleable GUI you’ve ever built with. It’s already the best coding experience I’ve ever had.

@bunjavascript Tests running in parallel, PR docs writing themselves in the background. The future of DX is just hitting 'Merge' and letting the infrastructure do the rest of the chores.

In the next version of Bun `bun test --parallel` runs test files in parallel

@akshay_pachaar Stale nodes poison AI agents and engineering teams. If you aren't auto-pruning dead docs the exact second a PR merges, your team's memory decays. Love this architecture.

Knowing what to forget is harder! Most agent memory systems focus on ingestion. Add more documents, build more embeddings, extract more entities. The graph only grows. But a memory that never forgets isn't actually useful. Stale nodes and unused connections pile up over time, and retrieval gets noisier. The agent spends compute traversing paths that haven't mattered in months. Real memory needs the opposite motion too. It should strengthen what gets used and let the rest decay. Think about a customer support agent. Product docs and refund policies get hit constantly. HR-related edges barely move. A static graph treats both the same way, but the traffic pattern tells you exactly which paths deserve priority. Self-improving memory uses that signal: → Track which paths retrieval actually uses → Strengthen the edges that led to good answers → Let unused nodes decay over time → Infer new connections from recurring usage patterns This is what memify() does in Cognee. It runs an RL-inspired optimization pass over the graph, tuning edge weights based on real traffic rather than assuming every connection is equally important. Over time, the graph reshapes itself. The paths your agent actually needs get faster and more reliable, stale branches fade out of retrieval, and the memory develops its own sense of what matters for your specific use case. That's the real shift: from storage that holds knowledge to memory that learns from how knowledge gets used. Cognee is open source and gets you here with a pip install. The default stack is embedded (SQLite + LanceDB + Kuzu), and swappable to Postgres, Qdrant, or Neo4j when you go to production. Check it out on GitHub: github.com/topoteretes/co… The article below is a first-principle deep dive on building agents that never forget. This will give you a clear picture of how memory for agents is evolving.

@delveroin Hey man! Building DocIt. It’s an autonomous agent that reads your git diffs and automatically updates your wikis/docs in the background. Built it so early teams can just hit 'Merge' and keep shipping without doing manual chores. ​whitelist.docit.in

Good day everyone Looking to follow more great founders. Drop what you’re building, let’s connect 👇

@csaba_kissi 100%. The biggest risk of AI coding is the repo becoming a black box. If devs are shipping code they don't fully understand, having a background agent automatically read the PR diff and document the architecture in plain English is the only way the rest of the team survives.

Unpopular opinion: Copying AI-generated code without understanding it is worse than copying from Stack Overflow.

@GergelyOrosz This will force engineering teams to actually measure AI ROI. If budgets are capped, spending it on code-gen (which increases tech debt) makes less sense than spending it on background agents that automate the chores, like reading PR diffs to keep documentation perfectly synced.

There is massive irony in how AI coding tools are starting to become TOO expensive for many enterprises - after eg Anthropic removed subsidizing AI subscriptions. We might go from "everyone use AI for everything!" to "you have $300/month AI budget; use your brain for the rest."

@theo 100% right. Forcing devs out of their IDEs into a new terminal wrapper was never going to last. The real future of AI agents is zero-interface. We stay in our IDEs, push code, and background agents live in the CI/CD pipeline doing our chores (like auto-updating the docs).

Was I right?

@theo Challenge accepted. We are building an autonomous agent that reads PR diffs and updates architecture docs. Since it touches live repos, we are paranoid about hallucinations. I would legitimately pay you to try and break our ingestion layer.

High alpha move someone should make: "sponsor" me, but instead of selling your product, I spend the ad read showing as many bugs as I can find in your product. Once I can't find bugs, I'll shift to talking about how impressed I am that you solved them all.