Hacker News

However, the more we spoke to users the more we realized that non-technical users were actually using skills more and more but they had no way to share. And there was no way you were going to get your legal team to install and learn git.

SX 2.0 is targeting non-technical teams by adding a native Mac, Windows and Linux app. Our vault format was reworked so it can be used directly as a claude or codex plugin. And by storing your vault in Dropbox, Google Drive, iCloud or others you can be up and sharing in under a minute.

2.0 also adds an extension system with extensions that manage Skill Evals, LLM de-duping, metics and much more https://github.com/sleuth-io/sx-extensions.

It's Apache-2.0 and you can download it here https://github.com/sleuth-io/sx.

I'm Kevin. I built ContextVault because I kept running into the same problem with AI tools.

Every project accumulated prompts, coding conventions, architectural decisions, examples, and other pieces of context that made the models significantly more useful. The problem was that this information quickly became fragmented. Some lived in ChatGPT Projects, some in Claude, some in Markdown files, some in internal documentation, and some only existed in previous conversations.

Late last year, I realized several people on our team were solving the same problems independently because previous work was difficult to discover. I assumed this problem existed in other large organizations, so I started experimenting with a shared context store.

I started with a local proof of concept and a rough MCP server. If I asked questions like "have we done this before?", the AI could search the database and find the most relevant item to review. If a conversation produced something worth remembering, I could say "save what we learned to the vault." After using that workflow for a few months, I found myself relying on it every day.

I decided to make it available to others. I've never built a product before, and I thought it would be a valuable learning exercise to do.

ContextVault is a a product for storing and organizing reusable context that can be shared across people, projects, and AI tools. Instead of copying the same instructions into every conversation, you can store them once and retrieve them through our MCP server. It is not limited to any one AI client. Your team can use ChatGPT, Codex, Claude, and Gemini and save/read from the vault all the same.

It currently supports:

- OAuth support for GitHub, Google, Microsoft, and GitLab

- Structured context records with metadata

- Multi-user organizations with role-based access

- MCP server for all AI clients that support MCP

- Organization-scoped storage keeps tenant data separated

- Group visibility rules decide which memories each member can search

- Authenticated MCP access ties every request back to a real user and workspace

- Feedback signals can be captured now and used to improve ranking later

- Supports desktop versions of AI clients, not just their CLI versions (mobile app support should also work)

The backend is built with PostgreSQL, pgvector, Node.js, and TypeScript. The frontend uses Next.js, React, Tailwind CSS, and shadcn/ui (frontend is not my strong suit, please be kind). Authentication is handled with Clerk and billing with Stripe.

I started building this for my own workflow, but after relying on it for several months I decided to make it available to others. We soft launched a few weeks ago, and I find it useful as a daily tool.

Essentially, ContextVault offers a way to track memories and context, distribute them instantly to your team, and help reduce duplicated work.

I'd be interested in feedback on a few things:

- How are you managing reusable AI context today?

- Are you relying on similar tools, or do you keep everything in Git or Markdown?

- If you've built something similar, what did you learn that you would do differently?

You can see the product here:

https://www.contextvault.dev

There are services that transcribe music from Youtube videos into tabs, but they never work well enough for me. Instead I'm taking a simpler approach. It downloads the video, samples frames, uses Claude vision to locate the tab region, crops every frame to that region, de-duplicates the crops by the bar number printed on each line of the score, and stitches the distinct tab lines vertically into a PDF.

I didn't test it on a lot of different Youtube videos yet, so problem will arise for sure.

With down time on a warm beach during a heatwave, cool salty water giving me fresh ideas, I had an idea: what if we used Coiled's Geospatial benchmark discussion as a comprehensive overview of geo and climate queries. Are all of these common operations secretly relational, just with the wrong data model? Using Claude Code on the beach, I can confirm that this seemed to be the case: Claude and I publish a benchmark that illustrated how every common operation in geo and climate sciences (at the 100 TB range) were actually secretly relational operations: https://github.com/xqlsystems/xarray-sql/blob/main/docs/geos....

Most surprisingly of all, from these examples was that a core operation, regridding, was just a sparse matrix-vector product. Claude had pointed out to me that in this data model, matmul was just a `SUM(val * val) ... JOIN .. GROUP BY`. This has a direct parallel to einsum notation, but can be expressed in (arguably) elegant SQL syntax! This capability seemed to be greater than the sum of it's parts.

Back in the cool water of the Ionian, I thought about the implications of this more deeply. I reflected that, all of the Coiled benchmarks did, deep down, was _post process_ simulations that happen in numerical/array code. Why couldn't these physics calculations be push down into the database also, if we could so matmul in SQL? Then it hit me: maybe they could, if in addition to linear algebra, if SQL could do calculus! https://bsky.app/profile/al.merose.com/post/3mpbods7wts2y

Later on, I implemented autograd on top of DataFusion's visitor pattern based on JAX's implementation. In my simplified array model, it turns out that we only care about partial differentiation on the diagonal of the Jacobian, meaning that `grad()`, `jvp` and `vjp` are just row-wise operations! I then implemented a common physics calculation from the coiled benchmark that required gradients. From here, I realized if I can autograd in the database, why can't I create a neural network?

As I came back home, I created some slides, and presented this work to DataFusion's inaugural showcase: https://www.youtube.com/watch?t=1511&v=5o-4hL8vGPw&feature=y... I realized in this synthesis that SQL is not necessarily a toy language for writing neural networks, but in fact, may be highly desirable in the future due to the fundamental principles of relational databases: the logical layer should be independent from the physical layer. If that property holds, and a neural network is a series of relations, could we create a SOTA distributed system for training more easily? For example, if we had one global logical plan of dataflow, could we better distribute work on 1000+ GPUs?

Several scientists and engineers and I are working together to explore this weird world of relational arrays at https://xql.systems (discord link at the bottom if you want to get involved).

To create the design, I had AI analyze the ASTs of several mainstream languages plus a few of the conceptually groundbreaking but esoteric ones (listed in the README) and then create a new structure and new syntax. It was named after the Jacquard machine (https://en.wikipedia.org/wiki/Jacquard_machine), a precursor to Babbage's Analytical Engine (and punch cards).

The result reused a lot of existing ideas but combined them in what I found to be an interesting way. External/world effects are visible in function signatures, and the runtime requires explicit permission to touch the filesystem, network, etc. Effect interactions can be recorded and replayed to see what happens under different conditions or code. And since code is given a content-addressed semantic identity internally, renames and formatting changes don't require recompile or retesting.

Another piece that fell out of this was a testing framework called Warp, which combines replay, results caching, handler substitution, and a few other tools that I frankly wish I had when writing Python. There are a few examples available in the demos directory.

There's more to do, but it's installable and usable. I'm hoping people will have their agents digest the docs/SKILL.md file and maybe write a few programs or see where it might fit in their projects. It should be particularly useful in agent systems. If an agent says something is painful or you as a human find the code tough to understand, I'd like to hear about it so I can address it.

More detail here:

Repository: https://github.com/jbwinters/jacquard-lang

Further intro/human-oriented write-up here: https://research.friendmachine.co/jacquard/

Edit: Here's a demo video: https://www.youtube.com/watch?v=VV8PEAjxwQI

I reverse-engineered ride-hailing mobile apps to understand how they fetch prices from their servers. You sign in to my app with your ride-hailing accounts, and then my app requests live prices from the same APIs that ride-hailing apps use. Importantly, my app is built using an on-device approach: the app on your phone stores authentication tokens locally and sends network requests directly to each ride-hailing company’s servers. This keeps your accounts private. I wrote a blog post showing network requests sent by my app, which you can verify yourself: https://blog.hackney.app/p/how-hackney-works

This seems like an obvious app. Why doesn’t it already exist? That’s because most ride-hailing companies don’t offer public APIs for prices and wait times. Uber does offer one, but they prohibit using it for price comparison. When someone built a comparison app using the official API, Uber terminated their API access (https://www.benedelman.org/news-053116). There are apps today that don’t use official APIs, but they run your account tokens through their servers and send price requests server-side.

To integrate a ride-hailing provider, my app sends network requests for sign-in, token refresh, ride prices, and ride history (to power a feature that shows you unified ride history across apps and how much you’ve saved on each ride). Some ride-hailing apps implement certificate pinning to prevent you from viewing their network requests, and some communicate with their server using Protobuf, a data format that doesn’t include the original field names. Building an app using this approach is technically complex, but it makes possible all sorts of useful products that couldn’t otherwise exist.

The app is completely free. In the future, I may monetize through a subscription or partnerships with ride-hailing companies. I’d love to hear your feedback. You can download it today.

iOS: https://apps.apple.com/us/app/hackney-compare-rideshares/id6...

Android: https://play.google.com/store/apps/details?id=app.hackney