georgeck

The day this story was posted on Show HN, I didn’t want to be glued to the screen, waiting for new comments. So, I asked Gemini to write a script that listens for new comments on Firebase. I already had Pushover [1], so I connected the script to send notifications to my mobile device. I ran the script and forgot about it. Today, I woke up to multiple notifications. I believe this script could be useful for other HN users as well, so I converted it into a project and posted it to GitHub [2].

This is unrelated to Memento.

[1] https://pushover.net/

[2] https://github.com/latentsignal-org/hn-comment-watcher

Wanted to call out that the demo of the Enron dataset [1] is based on a private fork of Memento. Since the archive contains multiple inboxes, we had to make Memento pick one of the users as the central user. These changes are not in the main repo as it is not a regular use case.

[1] https://memento-demo.latentsignal.org

Great feedback. It would be great to connect Memento to Slack and possibly the user's photo archive as well. And if we can map the canonical user across all these stores, the Memento can show the unified view for all your memories.

Thanks for the feedback. The system prompt for the web app is optimized to balance between too short a summary vs not long enough. The browser extension, on the other hand, allows you to customize the system prompt to make the result exactly the way you want.

Another option is to look at the Bluesky feed [0]. This bot looks at top stories in HN and creates a very short summary. It only does around 20 posts a day. That could be limiting too.

[0] - https://bsky.app/profile/hncompanion.com

Fair enough. I completely understand that the experience and hunting for gems in the comments is the core appeal of HN for many and AI summaries definitely aren't for everyone.

That said, we are seeing a consistent daily user base who do find value in the summarization, so it seems to be solving a pain point for a specific segment of readers, even if not for all.

Apart from the AI features, we actually built HN Companion as a general power-user client. It supports keyboard-first navigation (vim-style J/K bindings for comment navigation), seeing context for parent/child comments without losing your place, and tracking specific authors across a thread.

You might find those utility features useful even if you ignore the summary sidebar entirely. In the browser extension, the summary panel is something the user have to activate - it doesn't show-up by default.

Another interesting link relevant to AI summaries for HN discussion is the utility created by simonw [0]. Our tool is quite similar to what simonw did, except that we make the back-links more seamless. If you’re interested in a standalone tool similar to what simonw developed, you can find our script here [1]. If there’s community interest, we can improve the user experience of this tool.

[0] - https://til.simonwillison.net/llms/claude-hacker-news-themes

[1] - https://github.com/hncompanion/skills-scripts

Another interesting feature for HN users in the companion Bluesky bot we created [0]. It analyzes top stories from HN [1] and generates a new Bluesky thread every hour using the same cached summary. This bot is operational for the last 8 months.

[0] - https://bsky.app/profile/hncompanion.com

[1] - https://news.ycombinator.com/best

When people hear about AI summaries, this is what comes to mind. And I understand their concern. Wouldn’t a summary strip away the essence of a conversation? Let me explain with an analogy. When we’re overwhelmed with information, we benefit from a system that organizes it. For instance, I might use a tool to declutter my desktop files and categorize them into logical groups. Once the categorization is complete, I can view these clusters and focus on the specific files within those clusters that pique my interest. However, if the summarization process also alters the files, I wouldn’t want to use that tool.

In the context of HN Companion, our objective is to examine lengthy threads and group them into 3 to 4 topics. Within each topic, we present the actual discussion that represents that cluster. We invested significant effort in developing a system that enables you to not only read the actual comments but also seamlessly jump to that discussion and continue the conversation there.

I encourage you to explore a few of the summaries in the app. I’d greatly appreciate your feedback on how we can enhance our service.

Thanks a lot, Rayshan!

Your feedback through GitHub issues has been instrumental in helping us prioritize specific features. Additionally, the Chrome Web Store team has approved our extension for their ‘Featured’ badge, which could enhance the trust in installing the extension. I’m curious to know if you’ve had a chance to try the web app.

HN is all about the rich discussions. We wanted to take the HN experience one step further - to bring the familiar keyboard-first navigation, find interesting viewpoints in the threads and get a gist of long threads so that we can decide which rabbit holes to explore. So we built HN Companion a year ago, and have been refining it ever since.

Try it: https://app.hncompanion.com or available as an extension for Firefox / Chrome: [0].

Most AI summarization strips the voices from conversations by flattening threads into a wall of text. This kills the joy of reading HN discussions. Instead, HN Companion works differently - it understands the thread hierarchy, the voting patterns and contrasting viewpoints - everything that makes HN interesting. Think of it like clustering related discussions across multiple hierarchies into a group and surfacing the comments that represent each cluster. It keeps the verbatim text with backlinks so that you never lose context and can continue the conversation from that point. Here is how the summarization works under the hood [1].

We first built this as an open source browser extension. But soon we learned that people hesitate to install it. So we built the same experience as a web app with all the features. This helped people see how it works, and use it on mobile too (in the browser or as PWA). This is now a playground to try new features before taking them to the browser extension.

We did a Show HN a year ago [2] and we have added these features based on user feedback:

* cached summaries - summaries are generated and cached on our servers. This improved the speed significantly. You still have the option to use your own API key or use local models through Ollama.

* our system prompt is available in the Settings page of the extension. You can customize it as you wish.

* sort the posts in the feed pages (/home, /show etc.) based on points, comments, time or the default sorting order.

* We tried fine tuning an open weights model to summarize, but learned that with a good system prompt and user prompt, the frontier models deliver results of similar quality. So we didn’t use the fine-tuned model, but you can run them locally.

The browser extension does not track any usage or analytics. The code is open source[3].

We want to continue to improve HN Companion, specifically add features like following an author, notes about an author, draft posts etc.

See it in action for a post here https://app.hncompanion.com/item?id=46937696

We would love to get your feedback on what would make this more useful for your HN reading.

[0] https://hncompanion.com/#download

[1] https://hncompanion.com/how-it-works

[2] https://news.ycombinator.com/item?id=42532374

[3] https://github.com/hncompanion/browser-extension

Congrats on the launch! How does this compare to https://finetunedb.com

This was discussed previously on HN: https://news.ycombinator.com/item?id=36089176

Thanks, that’s helpful.

I’m also hoping similar media management options are available on iOS and desktop, since I use Signal across devices.

By the way, does Signal treat synced devices (like desktop or a second phone) as “replicas” vs a “primary”? If so, does this affect how storage or message history is handled between them?

Would appreciate any insight from folks familiar with the technical side of this!

It would be really useful to have more client-side control over media storage. That way, I could better manage storage growth without wiping entire threads.

For example, being able to see all media across chats, sort by file size, and optionally group by conversation would make it much easier to clean things up.

SQLite's backward compatibility means many best practices - like WAL mode, foreign key enforcement, and sane busy timeouts - are not enabled by default.

The author's Go library, sqlitebp, automates these settings and others (NORMAL synchronous, private cache, tuned page cache, connection pool limits, automatic PRAGMA optimize, and in-memory temp storage) to make high-concurrency, reliable usage safer and easier right out of the box

This is a great idea! Exactly what I was also thinking and started working on a side-project. Currently the project can create summaries like this [1].

Since HN Homepage stories change throughtout the day, I thought it is better to create the Newsletter based on https://news.ycombinator.com/front

So, you are getting the news a day late, but it will capture the top stories for that day. The newsletter will have high-level summary for each post and a link to get the details for that story from a static site.

[1] - https://news.ycombinator.com/item?id=43597782

I tried summarizing the thread so far (339 comments) with a custom system prompt [0] and a user-prompt that captures the structure (hierarchy and upvotes) of the thread [1].

This is the output that we got (based on the HN-Companion project) [2]

LLama 4 Scout - https://gist.github.com/annjose/9303af60a38acd5454732e915e33...

Llama 4 Maverick - https://gist.github.com/annjose/4d8425ea3410adab2de4fe9a5785...

Claude 3.7 - https://gist.github.com/annjose/5f838f5c8d105fbbd815c5359f20...

The summary from Scout and Maverick both look good (comparable to Claude), and with this structure, Scout seems to follow the prompt slightly better.

--

[0] - https://gist.github.com/annjose/5145ad3b7e2e400162f4fe784a14...

[1] - https://gist.github.com/annjose/d30386aa5ce81c628a88bd86111a...

[2] - https://github.com/levelup-apps/hn-enhancer

Is this solution similar to the Direct Preference Optimization (DPO) [1] provided by another 'fine-tuning as a service' - OpenPipe?

[1] https://docs.openpipe.ai/features/dpo/overview

> To quickly find text, select some text and press ⌘E followed by ⌘G.

This is really nice. Once I am in this 'search' mode, I couldn't figure out how to get out of this mode.

- Edited to make question more descriptive.

Tools like https://pi-hole.net does this for the whole house. It comes with a default set of blocked domains and you can easily add to it. It acts as your local DNS for the network.

Thank you for trying out the extension and for this great suggestion!

We've actually been thinking along similar lines. Here are a couple of improvements we're considering:

1. Built-in prompt templates - Support multiple flavors (e.g. On similar to is there already, in addition to knowledge of up/down votes, another one similar to what Simon had - which is more detailed etc.)

2. User-editable prompts - Exactly like you said - make the prompts user editable.

One additional thought: Since summaries currently take ~20 seconds and incur API costs for each user, we're exploring the idea of an optional "shared summaries" feature. This would let users access cached summaries instantly (shared by someone else), while still having the option to generate fresh ones when needed. Would this be something you'd find useful?

We'd love to hear your thoughts on these ideas.

I have been trying to approach the problem in a similar way, and in my observation, it is also important to capture the discussion hierarchy in the context that we share with the LLM.

The solution that I have adopted is as follows. Each comment is represented in the following notation:

   [discussion_hierarchy] Author Name: <comment>

To this end, I format the output from Algolia as follows:

   [1] author1: First reply to the post
   [1.1] author2: First reply to [1]
   [1.1.1] author3: Second-level reply to [1.1]
   [1.2] author4: Second reply to [1]

After this, I provide a system prompt as follows:

  You are an AI assistant specialized in summarizing Hacker News discussions. 
  Your task is to provide concise, meaningful summaries that capture the essence of the thread without losing important details. 
  Follow these guidelines:
  1. Identify and highlight the main topics and key arguments.
  2. Capture diverse viewpoints and notable opinions.
  3. Analyze the hierarchical structure of the conversation, paying close attention to the path numbers (e.g., [1], [1.1], [1.1.1]) to track reply relationships.
  4. Note where significant conversation shifts occur.
  5. Include brief, relevant quotes to support main points.
  6. Maintain a neutral, objective tone.
  7. Aim for a summary length of 150-300 words, adjusting based on thread complexity.
  
  Input Format:
  The conversation will be provided as text with path-based identifiers showing the hierarchical structure of the comments: [path_id] Author: Comment
  This list is sorted based on relevance and engagement, with the most active and engaging branches at the top.
  
  Example:
  [1] author1: First reply to the post
  [1.1] author2: First reply to [1]
  [1.1.1] author3: Second-level reply to [1.1]
  [1.2] author4: Second reply to [1]
  
  Your output should be well-structured, informative, and easily digestible for someone who hasn't read the original thread. 
  Use markdown formatting for clarity and readability.

The benefit is that, I can parse the output from the LLM and create links back to the original comment thread.

You can read about my approach in more detail here: https://gist.github.com/simonw/09e5922be0cbb85894cf05e6d75ae...

I agree. Capturing the interaction as a movie (like .mov file) makes it really difficult to understand what the user is doing. e.g. What keystrokes did the user press to finish this interaction. I wish folks would post screen grabs with tools like https://asciinema.org/ - this is what the helix-editor homepage uses to show the features. This is ideal for terminal apps.

That said, I wish asciinema can also show the key strokes a an annotation with the ability for the viewer to pause on each keyboard interaction.

One of the coauthors here - the tool uses the following data pipeline.

Resume data in unstructured format (including PDF) -> structured data with Claude’s structured JSON API -> portfolio templates that take structured data input -> further refinement using prompts in IDEs like Bolt or V0 -> publish in Vercel, Netlify etc.

This allows the tool to be generic and not tied to LinkedIn.

> We’re only testing models up to 4b, as larger ones don’t run well on this Jetson.

According to spec, this model has 4GB 64-bit LPDDR4 (25.6GB/s) memory