jfim

The good thing is since the feature was cheap to implement, you can just say "this was a bad idea" and remove it, as long as adding that feature wasn't a one way decision. People are typically more reticent to remove things that were hard to implement, even if that's the right thing to do.

That's what they're working on, in theory, with Windows K2.

A few reasons. Learning is one of them, since I don't normally deal much with browser and web related technologies, so it's a good way to learn more about them.

I also think there are a few interesting things you can explore that go beyond a simple carbon copy of what's on the Internet. Ideas that I've implemented are things like automatic extraction of audio tracks, transcription, and summarization, loading a page or podcast transcript into the context window of a LLM to discuss the arguments or factuality of the claims being made, automatically turning articles to reader view using readability/trafilatura, etc.

Directions I'd like to explore would be things like multimodal search ("that page I read six months ago about computer security with neon green text on a black background", or give me a list of fitness related pages I've read in the last twelve months), personal statistics (how is the mix of topics I've been reading about changing over time), annotating pages instead of just passively reading them, maybe even P2P archiving or discussions about pages, and all kinds of other things.

But installing archivebox would be easier indeed.

Prototypes aren't only for UX though, sometimes they're for exploring whether something is technically possible, or what are the unknown unknowns in a particular area.

For example, for personal projects, I've been wondering if it's possible to automatically create RSS feeds for pages that don't have them (yes), what are the challenges when building an archive-style page dumping system (need to dump CSSOM alongside getOuterHTML, remove/rewrite remote content, walk iframes, automate Chrome, scroll to load lazily loaded content, etc.), and if training a model to remove native ads from markdown coming from readability is possible (no, at least not with my current approach, but using the dom might work).

Claude is https://claude.ai/new?q=%s

Archived version This repository is a mirror of the version currently found on source forge, duplicated here in an effort to no help preserve this tool into the future. I, Julia Desmazes, have not contributed in any way to the development of this tool, all credit belongs to the original author.

In addition to being a command line tool, this tool also used to be available interactively though the now defuncts OutputLogic website.

It's bumping to manager level, except without the 1:1s, quarterly/yearly planning, headcount and budget reviews, org/reorg discussions, performance calibration, and OKR planning. No complaints about the last review cycle or about the upcoming one.

That's already the case with say bf16

Still trying it out, but here's my feedback so far:

- Overall the approach is sound, to generate various levels of documents from requirements to finer grained ones

- I'm not sure if that's intended, but I got asked about four questions and then the model one shot all three documents at once, ideally you'd work on one at a time, then once you're happy generate the next level of documents

- The prompting by the model was very shallow, it didn't ask enough questions so the requirements were off. I was expecting more questions so that the model had more information to work with. The docs can be iteratively reworked but I think it should make a better effort at the first take.

- I don't think there's any versioning of documents but that would be useful

- Dispatching subagents to review the generated plans would be nice

Overall it's pretty reasonable, I can see it being pretty useful. Send me an email if you need more details.

Sure, I'll take a stab at it, that looks interesting. I'll give you an update in a couple of hours.

There's a long tail of unpredictable events in the AV industry that you end up seeing, especially since the cars in aggregate end up driving more than one could over a lifetime.

At a previous employer, we've seen anything from cars getting mooned, a SUV slowly driving past the AV, the rear window roll down, and someone poke their head out and start throwing dollar bills at the AV, a convention of people dressed up in animal costumes, the "Miami left," and so on.

So it's much less of "maybe we should test that" and more of "we don't know what we don't know, so let's gather some data." In practice, the cars have lidar so they won't crash into solid objects that aren't recognized, they just end up getting stuck in embarrassing situations like these.

He's probably talking about the desktop version, which afaik doesn't officially exist on Linux. There are Debian packages that repackage the electron code though: https://github.com/aaddrick/claude-desktop-debian

Those are really cool!

I was thinking of printing one that's like the California example (https://github.com/open-energy-transition/grid2poster/blob/m...). Where do people print posters nowadays?

Not the parent, but since the liveview state is on the server side it means that one server can't support a large number of concurrent sessions, for some value of large.

Building a personal internet archive and knowledge management stack. It's in a rough state but I'm using it every day.

Cham (https://github.com/jfim/cham) is an archive for internet content, you give it an URL and it'll archive it for you, extract the text with readability if it's an article, or extract the audio track then transcribe it. Content is automatically summarized and tagged, and you can start a conversation with a LLM about the article. It supports feeds too so you can subscribe to blogs and keep the articles in case the blog goes away. I still need to add search, improve the CLI, add all the missing features, and do a lot of improvements all over the place.

To improve reliability, I made passe-partout which is basically a Chrome browser with a rest API (https://github.com/jfim/passe-partout) and veilleur (https://github.com/jfim/veilleur) which turns any blog listing into a RSS feed. So this way I can take blogs that are rendered using JavaScript, don't have a RSS feed and load the articles directly into Cham.

Also built a modular MCP server with OAuth2 dynamic registration so that I can have my own MCP server that works with the web, desktop, and cli versions of Claude/Claude code. Currently have modules for editing files so that I can edit/search my Obsidian vault from Claude, fetching pages through passe-partout (since some pages block LLMs from reading them), and proxying MCP servers so that servers that only support bearer token auth can still work with web Claude.

Also, a gnome terminal emulator UI with some unique features like split browser/terminal tabs. https://github.com/jfim/jfterm

Mostly an excuse to see how far I can push LLM code generation to write tons of software that I've always wanted but never had the bandwidth to tackle, and learning to deal with the sometimes questionable code quality that comes from it.

I'd say there's another camp: the camp of people who know that code isn't the hard part, but that it's still time consuming to write code. AI coding is pretty useful for that, when you can nail the design but you just need a set of hands to implement it.

I've seen one recently where it's basically a series of animated objects and you're asked to click on the slowest one. It's surprisingly easy as a human, but anything that depends on a single screenshot of the page isn't able to solve it.

Obviously, that's only solveable by sighted humans, not ones that are blind or have otherwise low vision.

They also don't mention what their sample size is, or anything about the distribution of input and response lengths.

It'd be interesting to see the distributions if the author actually plotted the data, so we could see if their analysis holds water or not.

A plot of the input lengths using ggplot2 geom_density with color and fill by model, 0.1 alpha, and an appropriate bandwidth adjustment would allow us to see if the input data distribution looks similar across the two, and using the same for the output length distributions, faceted by the input length bins would give us an idea if those look the same too.

Edit: Or even a faceted plot using input bins of output length/input length.

I've seen Claude use sed to edit files on other hosts instead of copying the file back and forth to edit it. Not quite full blown OT but it's going in that direction.

I don't think they can, but at the same time they can appeal a judgement that's unfavorable to them. Appeals in small claims allow for having attorneys present, at least in California, and it's another day in court that you'll have to argue your case.

My guess is that it's to ensure that the UI logic crashing or hanging doesn't bring down the safety critical process.

> This branch is 3026 commits behind openclaw/openclaw:main.

Sounds more like an intern who accidentally forked a repo under the Microsoft org instead of their personal account.

They're not typically used for passenger cars, but semi truck drivers and first responders use them since they're visible from farther away in both regular and low visibility situations like fog, rain, and at night.

That's pretty much impossible though.

One workflow that some artists use is that they draw with ink on paper, scan, and then digitally color. Nothing prevents someone from generating line art using generative AI, printing it, scanning it, and coloring it.

And what if someone just copy pastes something into Photoshop or imports layers? That's what you'd do for composites that mix multiple images together. Can one copy paste screenshots into a multi layer composition or is that verboten and taints the final image?

And what about multi program workflows? Let's say I import a photo, denoise it in DxO, retouch in affinity photo, resize programmatically using image magick, and use pngcrush to optimize it, what metadata is left at the end?

Out of curiosity, what can parallel tool calls do that one can't do with parallel subagents and background processes?

Some of the Chinese labs with cheaper per token costs do support it, like say minimax: https://agent.minimax.io/max-claw

I haven't tried it to see if it's any good but it's $20/mo.

It's C++, and basically what Arduino gives you is

  int main() {
    setup();
    for(;;) loop();
  }

As well as a GUI to easily flash devices and view the output from the serial port, as well as import libraries that do all of the hard work like say making a serial port on any microcontroller pin or control external devices like light strips or displays.

I'd assume the average user on HN should be able to figure it out pretty easily.

It's pretty trivial to do so on Arduino though.

  void setup() {
    pinMode(LED_BUILTIN, OUTPUT);
  }
  
  void loop() {
    digitalWrite(LED_BUILTIN, HIGH);  
    delay(1000);                     
    digitalWrite(LED_BUILTIN, LOW);   
    delay(1000);                      
  }

> If your paycheck depended on following the instructions of an AI robot, the world might start to look pretty scary real soon.

That's already the case, minus AI, for gig workers. Their only agency is to accept or decline a ride/delivery, the rest is follow instructions.

You can run steam in big picture mode, and there are ways to add links to games from other game stores to steam such as https://github.com/PhilipK/BoilR

It's not automatic or perfect but it does work.