neongreen
“Any agent on any VPS/VM” is an agent with self hosted infra. Lovable is an agent with managed infra. I think having managed infra is neat.
I think most solo devs would be better served by using Lovable than Codex or Claude, for the kind of apps Lovable is optimized for (i.e. CRUDs with thirdparty SaaS integrations).. and if you ignore the cost, b/c Codex sub is hard to beat.
Lovable is a normal, fully capable agent harness. With a Linux box. With all the usual features like MCPs, skills, subagents, browser, and whatever else.
You can ask Lovable to grab Rust from nixpkgs, write a raytracer, and compile to WASM, and it will happily do it. You can ask Lovable to write an OS in assembly and run it in v86, and it will do it. (I did both.)
The alternative to Lovable isn't Codex, but "Codex + Cloudflare account". I don't doubt that eventually Codex will be really good at using Workers and Durable Objects and R2 and serverless SQLite and Wrangler -- and having everything Just Work without needlessly exposing it to the user -- but idk I think it's not there yet.
https://arxiv.org/pdf/2505.09388
> Thinking Budget. An additional advantage of Thinking Mode Fusion is that, once the model learns to respond in both non-thinking and thinking modes, it naturally develops the ability to handle intermediate cases—generating responses based on incomplete thinking. This capability lays the foundation for implementing budget control over the model’s thinking process. Specifically, when the length of the model’s thinking reaches a user-defined threshold, we manually halt the thinking process and insert the stop-thinking instruction: “Considering the limited time by the user, I have to give the solution based on the thinking directly now.\n</think>.\n\n”.
^-^
---
Deepseek v4 Pro has three modes: no thinking, thinking ("high"), very good thinking ("max"). Max is implemented as follows:
https://huggingface.co/deepseek-ai/DeepSeek-V4-Pro/blob/main...
> When reasoning_effort="max" is set, a special prefix is prepended at the very beginning of the prompt (before the system message) to instruct the model to maximize its reasoning depth: > > Reasoning Effort: Absolute maximum with no shortcuts permitted. You MUST be very thorough in your thinking and comprehensively decompose the problem to resolve the root cause, rigorously stress-testing your logic against all potential paths, edge cases, and adversarial scenarios. Explicitly write out your entire deliberation process, documenting every intermediate step, considered alternative, and rejected hypothesis to ensure absolutely no assumption is left unchecked.
---
Inkling, apparently, trained their model to treat effort level as "how cheap is one reasoning token":
https://magazine.sebastianraschka.com/p/controlling-reasonin...
> During large-scale RL, they did two things for each sample: > > 1. Specified the desired effort level in the system message. > 2. Adjusted the cost assigned to each generated token. > [...] > > Then, at inference time, Inkling receives a system message such as Thinking effort level: 0.8, and adjusts its token usage accordingly.
Posts like this one always made me feel like I was a coward. Like there was.. unvirtuousness.. in not killing one’s darlings, not validating ideas, not quitting things in time, not looking for product-market fit.
I can report that looking for product-market fit, and everything else from the list above, became easier once I started taking antidepressants and adhd meds.
For example, it turns out deciding to punch yourself in the face with reality is much easier when you don’t feel, for example, like abandoning a project would be a giant betrayal and a thing one might in theory do but you must never do ever under any circumstances.
- - -
There are likely many people who have more capacity for self control, and who are genuinely helped by hearing moderately harsh truths because they can (1) take a look at their behavior, (2) realize it hurts them and their chances of success, (3) realize where they’ve been blind to reality, and (4) change.
I suspect that such people assume — maybe correctly in most cases — that if someone hasn’t done (4), it’s because they haven’t done enough (1-3), and this is the appropriate lever to push.
I don’t know how to finish this comment.
I've been programming since I was a kid. I enjoy it a lot, I like knowing how things work, I get excited about new compiler features, I stayed up every night for a week when I discovered Lean 4, etc etc etc.
At the same time I realized a few years ago that I just don't want to write any code ever. Or read any code. Coding is addictive and fun, but I'd rather talk to the computer and have things magically get done. (FWIW learning how to use LLMs feels more.. fulfilling, too)
Anyway. GLM 5.2 is nice and all, but I might have to spend half an hour guiding it to come up with a plan I'm happy with. And with Opus it could be 15 minutes. I'm still going to spend an hour talking to LLMs one way or the other, but with Opus it will be a less frustrating hour. If Fable gives me a frustration-free hour, I'll switch to Fable.
SC has its own Haskell compiler that produces bytecode that you can run locally, serialize, send to be executed somewhere else, etc. Most of the code still lived in a monorepo, though.
We did have a global data store (well, several) that any code could access. I was working on a more "normal" application that was still written in the SC haskell dialect but otherwise mainstream architecture -- postgres, deploying to a boring linux server, etc.
A colleague once described our dialect as "Python that looks like Haskell". This is an exaggeration, but a) we did use a lot of untyped dicts and everything-is-a-giant-relational-table structures, and b) my understanding is that the actual financial modelling was done in C++ and the SC Haskell was glueing things together. Idk.
About uv -- I did try to convert ppl to uv but it probably didn't spread further than my few colleagues at the Warsaw office.. well and also I merged a monorepo-wide documentation system that used sphinx and uv, but idk if it's still alive after I left.
I genuinely chose the language for one of my projects based on this reasoning. I want to be in the nice UX gang.
This is exactly what Unison (https://www.unison-lang.org/) does. It’s kinda neat. Renaming identifiers is free. Uh… probably something else is neat (I haven’t used Unison irl)
Turns out that sum of PV($X in 1 year) + PV($X in 2 years) + … converges even though the series is infinite. Look up “perpetual bonds”.
The value of $10 paid annually forever is probably $200-500 depending on [things].
Source: I work in a bank but I’m also shit at finance so take this with a large grain of salt.
- it’s only kinda open source if it’s not on GitHub,
- it’s definitely not open source if it’s not in Git,
- but it can regain its open sourceness if it has an open Discord and the devs are hanging out there.
Here, all my heuristics exposed. (I’m not claiming they’re true or sensible, just saying what my brain thinks.)
(if anyone from SC is reading this -- search our wiki for "Jujutsu" and come say hi!)
Pretty much a strictly better experience than git so far — I’m not going back. `jj undo` is something that I expect in every program now and get vaguely annoyed it's not there.
Not having index/staging is great. Checking out another branch, switching to work on another thing, fixing a typo in an unrelated module, etc are all frictionless. "I'll insert a new commit five-commits-ago, do the refactoring there, and resolve conflicts" turns out to be much nicer than "I'll do the refactoring here and carefully stage it hunk-by-hunk". (I get distracted a lot -- maybe if you aren't tempted by shiny refactorings, this isn't a big deal for you.)
The merge story is also great. I have a commit with multiple parents. I can add more parents to it, change parents, rebase it somewhere, move it around. I have no idea how "rebasing a merge" works in git, but I'm afraid to try. In jj I don't care.
There are a few issues with jj that happen to not be a big deal for me, but I can imagine they could be a dealbreaker for someone else:
- No submodules support (yet)
- No LFS support (yet?)
- Doesn't track renames (yet?)
- When you do `git pull` with rebase, git skips duplicate commits -- this is great if something got rebased/amended on the remote. I was always suspicious that `git pull` just works even if I rebased the branch remotely, and now I know why it works. jj doesn't handle this yet. Not a big deal unless two people collaborate on a branch and want to do it the jj-way with rebases of everything.
Then I switched to Haskell. No (useful) debugger there.
Now I write TypeScript, and.. somehow I never figured out how to do debugging in JS properly. Always something broken. Breakpoints don’t break, VSCode can’t connect to Node, idk. Maybe I should try again.
For TypeScript, they list an example with `instanceof`:
https://counterexamples.org/polymorphic-union-refinement.htm...
In the playground:
https://www.typescriptlang.org/play/?#code/GYVwdgxgLglg9mABA...
I haven’t read volume 1, but apparently half of it is about data scraping, and I expect it to be similarly detailed. So if I were you, that’s where I’d start.
Another option is looking for “robots.txt” at Google Scholar and trying various keywords like “legality”, “scraping”, “case law”, etc.
NB: according to https://www.gtlaw.com/-/media/files/webinars/ian-ballon-may-..., page 4-470, it’s possible that failing to process a DMCA notice may only lead to losing safe harbor for the material identified in the notice, not for the entire service.
So GitHub might just choose to ignore the notice for React, get sued, and win, all without losing the safe harbor.
For less popular repos, I would not be surprised if you could take down any repo literally by submitting a completely bogus notice.
But honestly I still don’t know how much leeway - legally - service providers have in applying their own technical/legal expertise when evaluating DMCA notices. I’d appreciate any sources (court decisions, textbooks, whitepapers, descriptions of actual industry practices, etc) on the topic.
I’m more interested in “why doesn’t the same approach work against big sites”. But it looks like the comment about 512(a) vs 512(c) clarified that.
Thanks!