whatl3y

try:

$ curl x.tty.news

I'm most excited about reducing friction for digital payments of APIs and resources in the agentic commerce world.

I think the first step is standardizing HTTP 402 using traditional, familiar payment rails like Stripe, then we can move to things like on-chain or other rails later.

I am building https://stripe402.com to try to make it dead simple for those building APIs/resources to get paid per request through stripe without user's needing to sign up for accounts, get API keys, any of that normal painful workflow required today.

Check it out and feedback welcome!

Smart search engine for the Epstein files from the DOJ built on a RAG pipeline that indexes and makes them searchable via natural language (i.e. LLM style). Documents (PDFs, HTML, images) go through text extraction with OCR as a fallback for scanned pages, then get sliced into ~500-token chunks with 50-token overlap. Each chunk gets a metadata prefix baked in (document title, source section) before being embedded into 1536-dimensional vectors through OpenAI's text-embedding-3-small. Those vectors live in PostgreSQL with pgvector, sitting behind an HNSW index with ef_search cranked to 400 (default is 40, which misses too much).

Queries hit the same embedding model, and the system pulls the top-K most similar chunks by cosine distance. There's a hybrid search mode too: it over-fetches 5x candidates from the vector index in parallel with keyword search (full-text search via a GIN-indexed tsvector column, falling back to trigram ILIKE when FTS returns few results). Results are merged using a slot reservation system: 60% of the final top-K comes from vector results ranked by cosine similarity, with up to 40% reserved for keyword-only matches that the vector search missed. Retrieved chunks get stuffed into a prompt with source metadata and sent to Claude Sonnet or GPT-4o with instructions to cite sources in bracket notation.

On the backend, pub-sub workers handle the indexing pipeline: text extraction, chunking, batch embedding in groups of 100, and firing off face detection through AWS Rekognition on images pulled from PDFs (very good in some cases, not so much in others). The query endpoint is free with some rate limiting, but also sits behind x402 micropayments ($0.50) that bypass rate limits when valid (it's not cheap to run these queries as of now). There's also an MCP server so AI agents can query directly as a tool.

Built with the help of Claude, so some of the tech (RAG via LLM, pgvector, etc.) is newish to me. Was a fun exercise!

I did not know this and appreciate the insight! Will definitely store this back of mind and try and remember to use block comments when needing to explicitly return a promise.

While this is fair and I don't disagree that changing a column name or possibly other schema changes using an ORM and it's subsequent migration scripts is potentially going to be a faster exercise than without one, changing a column name (or any schema change for that matter) in a database in my experience is rare. If you choose to use an ORM for reasons like it might (emphasis on might) be a bit faster and easier to change a column name than without one instead of for other more meaningful people or efficiency-oriented reasons of the day-to-day developer workflow is probably a poor approach.

Keep in mind I've installed and used an ORM in projects where the ORM is used only for migrations, but not used in application code and this is absolutely a fine reason to use one imo. But adopting an ORM for migration purposes and forcing or using in application code simply because it's installed isn't necessarily a good approach.

While some people are hard lined enough on their anti-ORM stance that it sort of becomes weird, I agree with you that my beef with ORMs comes from being burned before a couple of times by a super inefficient aggregation ActiveRecord did on GROUP BY queries that it 1. not only took a really long time to figure out why a particular page in our app was loading slow but 2. we ended up having to write raw SQL to fix it.

I think the answer of whether to use one depends on the type and load/volume of app you're working with combined with the dynamics, size, and skill level of your team(s). I'm extremely comfortable writing, profiling, query planning, and debugging SQL queries. Others aren't, and therefore having an ORM to query data in the DB with the syntax of the language you're using in your projects makes way more sense, if nothing other in order to speed your team up.

While some people are hard lined enough on this that I agree it sort of becomes weird, I can tell you my beef with ORMs comes from being burned before a couple of times by a super inefficient aggregation ActiveRecord did on GROUP BY queries that it 1. not only took a really long time to figure out why a particular page in our app was loading slow but 2. we ended up having to write raw SQL to fix it.

I think the answer depends on the type and load/volume of app you're working with combined with the dynamics, size, and skill level of your team(s). I'm extremely comfortable writing, profiling, query planning, and debugging SQL queries. Others aren't, and therefore having an ORM to query data in the DB with the syntax of the language you're using in your projects makes way more sense, if nothing other in order to speed your team up.

1. Don't rename your columns, but if you have to

2. project search and replace on $COLUMN_NAME

If your column name is a common keyword, variable name, etc. in your code base and it's difficult to find using project search, that's unfortunate, but we organize our backend code and tests in a logical enough way that it's never taken longer than an hour to create a PR to create a migration to rename a column and update all places in code that reference it.

While this is true, I've found over time it's easier for me to quickly see in my code if I need to `await` on something if the function is an `async` function and not just that it returns a Promise.

I prefer

async function foo() { return await new Promise(...) }

as opposed to

function foo() { return new Promise(...) }

They're the same thing for the most part but the latter I have to potentially dig deeper into the function to confirm it returns a promise compared to the former.

I think it's necessary to put emphasis on the "get-rich-quick schemes" part, and not the "blockchain/cryptocurrencies" part.

I hope you're not implying blockchain tech and all cryptocurrencies don't/can't provide real utility value, but if so I beg to differ substantially. I built a hook to the Stellar blockchain to store SHA256 hashes of audit evidence that can be validated against at a later time as tamper-proofing evidence. This is just one extremely simple use case, not to mention the entire Defi ecosystem that's being developed as we speak.

Lastpass is centralized so if they get breached your info will as well. This is a tool where you can use and write your own connectors to store you account info (w/ AES-256 but encryption) wherever you want with control in your hands.

This inspired me so I will find more time to do this as well. Went ahead and started at one of my favorite projects that I use across several professional and personal projects :)

https://github.com/actionhero/node-resque/issues/496

I've used the Night Eye Chrome extension for a white and it does a great job of converting any website/web app to dark mode.

> Why would you assume there is no proper conclusion

I wouldn’t and am not. It’s your responsibility to confirm one way or the other.

If this is a case of a disgruntled freelancer who isn’t getting more than what he/she wants even under a contractual and agreed upon arrangement, then I’ll gladly retract from my former concerns and sincerely apologize for my personal issues towards the matter.

But if this is almost literally anything else where the freelancer did work and wasn’t compensated under the terms of a contractual agreement, I will hold up my concern and maintain my disdain towards the matter.

The problem is though that it didn’t just “slip by” if OP tried to contact you/your team through various channels (email, whatsapp) for weeks as he says. This was either a complete mistake (ie OP didn’t do work for you) or a purposeful, coordinated effort to prevent paying OP (and I imagine others).

Your character is at stake here and again, a sleezy ghosting for years is almost certainly worse I assume for most people than a phone call, email, whatever to tell someone you unfortunately just can’t afford to pay them right now but will as soon as you can. That’s the biggest issue here.

> I must have let priorities slip

saying a metaphorical “fuck you, I can’t pay you for the work you did for my business” by ignoring OPs alleged many emails and correspondence to get compensated is just as bad if not worse than a literal “fuck you, I can’t pay you” imo, but I’m also one that appreciates honesty and not sketchiness or being ghosted even if the outcome is not in my favor.

So

1. I’m glad this is the most upvoted comment in order to provide visibility and

2. I’m glad the founder wants to make it right apparently by having the alleged freelancer send details to rectify

but the the fact that the founder doesn’t immediately refute that this occurred and only wants to now potentially make it right by having the freelancer send his details over to get paid is very troubling for me. I hope this comes out as a false allegation but if not I wouldn’t want to support this at all.

From someone who is working on a couple of now larger Typescript apps (both frontend and backend) I’ve began noticing compilation take long enough that I have a currently low hanging (but will obviously increase in priority) TODO to go through and refactor to improve compilation speed. I wouldn’t know how to google for this other than using the word “performant”. Although I realize in most cases performance specifically deals with production execution and what end users experience/perceive, I at least believe performance is not incorrect to describe what the author is helping with here.

I periodically suffer from what assume are symptoms of depression, but I can usually pinpoint the triggers that caused them (a lengthy social media session filled with large amounts of scrolling reviewing dozens of happy families hugging and kissing each other, a missed deadline that I'm emotionally connected to, a hangover, rainy weather, etc.)

Although I don't do this every time I suffer from the symptoms, usually a high intensity workout of some sort (a relatively fast 2 to 3 mile (or further) run, 45-60 min lifting session of fast paced lifts with super sets, etc.) will almost instantly "cure" my symptoms.

I can probably do some research or go see a doctor to confirm whether what I experience is anything potentially connected to depression, but I just haven't been motivated to and again, can usually fix what I'm feeling with a workout. Not really sure how to proceed, if at all...

Uhh, I would expect them to do exactly that for someone who presented them valid proof and and an MVP for how someone could get away with stealing tens, hundreds, thousands? of pizzas undetected. Rewarding someone for helping them with their “bread and butter” is how I would expect to be compensated for helping.

Couple of thoughts:

1. Although I agree it’s a problem, this isn’t new news I don’t believe. I don’t have good references to point to right this second, but I swear I hear almost monthly if not more often that most people couldn’t come up with $500-1k in an emergency, much less multiple months of expenses.

2. The article points to COVID-19 exacerbating these findings, but on top of the cash every US tax payer received who made under the defined threshold, there were a ton of things put in place or implemented like aid, loan forbearance plans, rent extensions etc. as apart of COVID-19. It seems a little (but I guess not totally) surprising that this crisis is what brought to light this issue.

It does look like they have a different, less “fatal” avenue to recover work related accounts[0], but I’d still be scared to host my FOSS repos there and make a mistake only to lose my account forever.

[0] “What if this is a work account?“ FAQ header in OP

> I suspect that support cost also played into the decision.

I respect this if it’s the case, but just say it, don’t hide behind a “best practice” security blanket when your true motive includes other factors.

> If there is no way to recover, it creates a perverse incentive to not use 2FA in the first place.

Agree. The user has to now perform a cost benefit analysis in her head to determine if she’ll use MFA with the most punitive risk being she loses access to her account forever.

> If you are caught where you are not able to provide your MFA token and without these backup methods, your account will be irrecoverable.

This seems absurd. I vaguely remember another SaaS tool I used that had this policy, but I don’t understand it. Even crypto exchanges allow recovery if you lose all traditional recovery methods by submitting documentation like your scanned driver’s license among a couple other pieces of info proving you are who you are.

If you offer MFA, I love the idea of following best security practices for users recovering their accounts when losing MFA devices/tokens/etc., but there has to be a “best practice” that includes recovering an account after a due diligence process has been followed proving who a user is who she says if she lost all normal recovery methods.

Edit: It does look like they have a different, less “fatal” avenue to recover work related accounts (“What if this is a work account?“ FAQ), but I’d still be scared to host my FOSS repos there and make a mistake only to lose my account forever.

It’s not the same if you complete the amount with cents. 100.00$ can become 9100.00$ much easier than $100.00.

I explicitly and carefully write out my tip and total with a dollar sign and cents and sometimes circle the total in an attempt to prevent the temptation for anyone to alter the amount (I’ve heard this happening to a could of friends back in college at restaurants and bars).

I've recently learned and ported a few projects from Javascript to TypeScript and I'll vouch that, so far, it is much better and easier to reason about my code and what it's doing. I also feel I need less test cases to adequately test my code.

In saying that, I'm interested in if there is any accepted, peer reviewed literature with quantifiable data as to whether strongly typed languages are "better" (whatever the study might define as better such as being faster, more scalable, etc). From what I've heard and read, most of the better-ness that strong typing provides is related to people problems and being able to scale a team, not necessarily scaling a system or making the system better. When learning Go and TypeScript after primarily writing Ruby and Javascript, I'm convinced of the better-ness strong typing provides whether it's related to readability, better IDE intellisense, or speed (although Go for example is faster then Ruby and JS not just because it's strongly typed, but compiled), I'm just interested in if there's real data to support using them instead of anecdata.

AWS CloudWatch logs is cheap and very easy to 1. integrate with existing loggers, 2. send logs to your desired log stream (and to send to multiple streams depending on if your in dev, testing, prod etc.) and 3. fetch/review via CLI or their web interface.

I have the same itch and keep scratching it almost daily. I can say scratching this itch over the last several years has absolutely been +EV overall. Maybe not in a “I made $XXXX in sales over the last month/year/whatever” kind of way but in that I’ve learned an incredible amount, have been able to use a lot of the things I’ve learned at my job and have definitely improved my overall market value as an engineer (validated with data I should say, not just an opinionated, arrogant rant).

That said, I would keep scratching that itch if you still have the motivation and drive to keep learning/building without seeing immediate material value like money right away.

So this finds the country based on some cloudflare-populated info of an incoming request (which sounds like it solved OP’s problem which is good), but if you want to use MaxMind’s database to find the country of any public IP I built the following a few months back:

https://github.com/Risk3sixty-Labs/geoapi

Even if slightly unrealistic, I actually think the nicest part is the back of the napkin math and derivation of the numbers to give you context for how big a market is and what you’d need to attack to meet your goals.

I do however have an issue with the wizard of oz method of validating your product. It’s not because of the perceived ethics and I totally understand too many people today build something before ever knowing anything about whether anyone will use or pay for it. Hopefully I didn’t miss it but nowhere does the author discuss the amount of time/people/money it would take to build a working MVP, not to mention how much of your time will be tied up from working on said MVP if you’re oz (i.e. the man or woman behind the curtain until the MVP is built). This is important since it drives how you (or at least I) would move forward: Do you need to quit a full time job and spend 3-6 months 60+ hr/week building your MVP, can you build an MVP in a few weekends, would you need outside help/money to build an MVP, etc etc.

The example in this post mentions a recommendation engine of sorts for individualized fitness programs. This sounds like a fairly high amount of expertise in the field of fitness, some possible AI with trained models sprinkled in and a good amount of curated fitness routine info or I guess individual exercises based on the equipment the user enters that they have. So a lot of time getting with experts (or becoming an expert) AND building a new machine learned model possibly with a nice, usable UI. This sounds like a full time job for 5+ people for 6+ months at least to get any sort of real prototype.