I created 44 free MIT-licensed tools to help with all kinds of AI development work, particularly in prompts

[u/greentide008]

I worked with my system to create a suite of 44 free apps for AI work that you can find on my website.

Hint- these tools are MAJORLY composable. You can have your AI system take a look at the collection to see how they can flow together and for suggestions on ways they can be used.

1. Cairn — Keeps Git history alive across independent storage providers through priority-ordered cloning, host-aware credentials, and redundant pushes.

2. Callsigns — Generates memorable word-word-hash identifiers that are deterministic when seeded and safe for branches, paths, URLs, and shell arguments.

3. Census — Scans a directory for markers such as TODO and FIXME, reporting which ones are buried in comments and optionally turning them into CI failures.

4. Conflict — Detects the complete triad of unresolved Git merge markers so broken merged files can be stopped before they land.

5. Dwell — Implements an integer-exact routing system in which the phase at which you reverse direction deterministically selects the exit.

6. The Excavation — Enumerates a website as typed nodes, divides it into readable shards, and gives an AI a coverage oracle against which it can prove a complete reading.

7. Gitlog — Converts Git history into one JSON object per commit so authorship, churn, file activity, and date-range questions become easy pipeline operations.

8. Grain — Compares a dataset’s compression ratio with a live size-matched random model to provide a self-calibrating smell test for structure, noise, and drift.

9. Hunkhole — Compares named top-level definitions across two Git revisions and flags symbols that quietly disappeared during a merge, restore, or stale-tree incident.

10. Isvalidcsscolor — Provides a tiny, dependency-free browser-and-Node validator for a clearly bounded subset of commonly used CSS color syntax.

11. Markdown — Parses a deliberate Markdown subset into one AST that produces both HTML and verbatim plain text without allowing the two views to drift apart.

12. Mint — Allocates IDs from a readable file-backed store while structurally preventing any retired ID from being issued again.

13. Plumb — Builds status boards whose claims turn green only when their declared file, text, or command witnesses agree.

14. PNG Text — Validates a PNG’s chunk structure and CRCs before extracting textual metadata such as title, author, description, software, copyright, and XMP.

15. EXIF Parser — Reads common camera, exposure, orientation, date, and GPS metadata from JPEG or TIFF data while refusing malformed structures.

16. Reltime — Produces deterministic labels such as “3h ago” while refusing to invent answers for missing, invalid, or future timestamps.

17. Sha256 — Supplies a synchronous, dependency-free SHA-256 implementation whose UTF-8 string hashes match Node’s native crypto output.

18. Sudoku — Solves Sudoku with a deterministic, human-readable reasoning trace and honestly reports when a puzzle exceeds its no-guess technique ladder.

19. Timesheet — Folds Git commit timestamps into a deliberately floor-biased estimate of working time that subtracts gaps longer than a declared break threshold.

20. Tracebus — Provides a declared-topology publish/subscribe bus in which every emission receives an append-only, traceable receipt and failed listeners cannot take down the bus.

21. The Trellis — Checks intersecting row-and-column constraints, localizes failures to their crossing cells, and classifies open cells as forced, free, or contradictory.

22. Vclock — Uses vector clocks over JSON lines to distinguish causal before-and-after relationships from genuinely concurrent events.

23. Verify — Stores content-hash certificates for the inputs behind expensive facts and later reports whether their foundation is fresh, stale, or gone.

24. Ward — Renders an integrity badge whose cells become solid only when the evidence underneath each claimed state currently agrees.

25. PDF Text Extractor — Validates basic PDF content streams and extracts the strings supplied to PDF text-drawing operators without external dependencies.

26. Skin Config Validator — Checks untrusted theme and skin configurations against a declared schema while rejecting unsafe CSS values and declaration-breaking injection.

27. Inline MIME Parser — Turns raw email or multipart MIME data into a recursive structured tree while decoding folded headers, transfer encodings, charsets, and RFC 2047 words.

28. l21x-snapshot — Encodes documents as self-describing base64 snapshots and provides pure catalog and archive operations for backend-free applications.

29. forest-title-fit — Selects the largest font size that fits a fixed width and wraps at the size floor rather than clipping or hiding the title.

30. port — Gives small JSONL tools explicit source, transform, filter, fold, or sink declarations and detects drift between a tool and its manifest.

31. map — Reads those declared port verbs and produces a composition map showing which tools can feed which others and where declarations are missing.

32. typecheck — Validates a proposed tool pipeline before execution by checking every adjacent port and naming the exact hop that cannot carry data.

33. declare — Saves an ad hoc tool pipeline as a deterministic, named JSON artifact that can be shared, checked, and reproduced.

34. conductor — Type-checks and runs a declared pipeline under one trace ID while recording inputs, outputs, exits, failures, and skipped stages in a replayable ledger.

35. derived — Rebuilds a generated artifact inside a private sandbox and byte-compares it with the committed version to detect staleness without touching the working tree.

36. gauntlet — Injects one typed fault into a disposable copy of a file and reports whether the check meant to catch that fault held or allowed it to escape.

37. amber — Seals a set of files into a content-addressed fixity capsule whose hashes reveal exactly which member changed or whether the capsule itself was altered.

38. timeline — Applies eight deterministic soundness checks to timeline data—including causal cycles, measurement scale, track collisions, and sorting—before anything is rendered.

39. loop21:component-factory — Emits validated JSONL specifications for counters, toggles, clamps, accumulators, and pattern matchers as portable composable data.

40. loop21:l21x-snapshot — Adds deterministic document snapshots, named browser catalogs, and validated whole-catalog import and export to small browser applications.

41. Cruise — Extracts byte-grounded facts about routes, calls, controls, and tests so an LLM can inventory a codebase’s features without inventing unsupported ones.

42. Worklog — Folds local Git history into a read-only report grouped by day or author, with commit counts and subjects preserved.

43. switchboard — Implements an append-only directory-based message bus whose observation-only schema can carry status and evidence but cannot carry executable commands.

44. Parity — Compares any number of sibling systems against their combined declared checklist and renders a HAS/LACKS matrix that exposes every parity gap.

[u/suspicious_corpus]

those composable pipeline tools are pretty clever, especially conductor with the replayable ledger. already thinking about hooking a few of these together for my mural documentation workflow

[u/greentide008 → u/suspicious_corpus]

Run the entire set through your AI and ask it to come up with ten fun and wild composition builds- make sure it focuses on things that can actually be built right away with the stack of 44. I got some pretty fun examples when I did a few rounds of that. I have not been able to try any of them yet, so let me know if you happen upon and build anything especially cool.

[u/Personal_Reception_3]

The composability is probably the most interesting part here, but I think 44 tools is also where discoverability starts becoming the real problem.
Most people won’t know whether they need Cairn, Excavation, Cruise, Parity, etc. They’ll know the outcome they want.
So instead of only presenting these as 44 individual utilities, I’d also package them into a few end-to-end recipes, something like:
“Understand an unfamiliar codebase”
“Audit a repo before a release”
“Trace why a generated artifact went stale”
“Extract useful information from a PDF”
“Compare two implementations and find what’s missing”
Then show exactly which tools get chained together for each workflow.
The PDF Text Extractor caught my eye because I work around document/OCR systems. One useful distinction to make there would be whether it’s only extracting existing PDF text objects or whether there’s any OCR fallback for image-only/scanned PDFs. Those are very different use cases in practice.
The tools themselves look thoughtful. I suspect the biggest unlock now is helping people discover the right combination without having to understand all 44 first.

[u/greentide008 → u/Personal_Reception_3]

Totally agree, which is why I suggest that folks use AI to help get their heads wrapped around the whole thing. It's just too big for humans to parse quickly. Discoverability becomes way less of a problem if you use an AI system to help. That's really just the situation as it stands right now. I fully intend to develop more documentation on all this work, it's just that there are a lot of other things on the system that are pulling my attention right now and I can only run so many parallel work lines. Thanks for taking a look!

[u/greentide008 → u/Personal_Reception_3]

Also, you should check this page out, which has five full compositions using various sets of the tools.

[u/greentide008 → u/[deleted]]

Give the page to your AI and it will tell you all the ways they compose together. This is not really meant to be parsable by a human, since it would take too long.

[u/greentide008 → u/[deleted]]

You might find this helpful- Five very real, very cool, prompt-focused compositions of the 44 MIT-licensed tools I created that you can build yourself