HNHacker News
TopNewBestAskShowJobs

joshka

2,489 karma · joined June 6, 2011

[ my public key: https://keybase.io/joshka; my proof: https://keybase.io/joshka/sigs/ElI6j13SI-_2rTrkLnoKyV-uDepH4JvAQAzp2OWV_W0 ]
submissionscomments
joshka··on I built a 100% local network privacy appliance to stop smart home spying
I read every bit of the site and still have no idea what this is / does.
joshka··on Show HN: OpenKnowledge – open source AI-first alternative to Obsidian/Notion
The same comments apply to each OS - scrolling / selection / hotkeys / controls / etc. all feel differently on each OS. macOS just has the general best of breed consistency with its own UX guidelines.
joshka··on Show HN: OpenKnowledge – open source AI-first alternative to Obsidian/Notion
Electron apps tend to fall down in the minutiae of the little things that native apps get right (around things like selection, scrolling, various small affordances across various levels). Would love to see something like this be more native app upfront, than starting out with something that will always leave that top 10% of what makes a nice feeling app unobtainable.

You win hard on this if you have the best possible UX that feels natural to drive. You just also ran if not because obsidian/notion etc. are already there (and have the people to put into those random edge cases that make electron apps bad).

joshka··on Show HN: OpenKnowledge – open source AI-first alternative to Obsidian/Notion
Consider making the first image in the readme either static, or move slowly enough that there's reasonable dwell time to understand the UI when it's done with rendering. Right now there's nowhere on the gif that you can focus on to understand that part of the app in any detail, so it's basically a flashy box of randomness.
joshka··on What I'm Finding About LLM Code Style and Token Costs
I think the reasonable thing that needs to happen here is frontier labs need to look at ways to incorporate better up to date gilded chunks of gold data into their post training. I'd love to be able to throw a chunk of scenarios and expected outputs for using various tooling and have this applied to gpt-next / opus-next. I recently did a test with having Claude do this for generating a skill for jujutsu vcs that was based on eval-ing and ablating many many instructions over hundreds of scenarios. This is good, but skill based post training costs tokens for every user rather than at the model level.

Maybe there should be a submit your post training corpus here thing somewhere.

E.g. this really comes down to advice changing in short time frames that aren't represented in data that satisfies knowledge cutoff which can be as long as 14 months in some things or more for older models. It's not just the problem of knowledge, but the grading of seen output. The models have been trained to produce the older style code because it compiles and solves the problems.

Here, the reframe that likely makes sense noting is that "Deno and runtimes like Cloudflare Workers implement the Web API surface natively", that's the strongest single thing that would help steer an agent to correctly write code for the code in question (assuming the Web API surfaces that are key are in distribution). Add something like - "Where there may be reasonable obvious updates that can be used in 2026, use them" ...

joshka··on What I'm Finding About LLM Code Style and Token Costs
Click the thumbs down report on the output (to better train the model in future to produce better code / provide signal to the people doing training that a common behavior is problematic) and then stick some guidance in your AGENTS.md. It can be fairly whack-a-mole at times on this sort of thing, but sharpening your personal saw with AGENTS.md is an effective approach to generally doing better.
joshka··on You can't unit test for taste
Pattern language sites / books have existed for years.

The right approach is more work out what shared patterns are, make sure a bunch of reasonable ones are post trained into the models so that it's easy to refer to them by name (e.g. "tim pope / chris beams style commit messages", or "make invalid state unrepresentable") and then you're in a world where you can define your personal tasted through labels rather than repetition of the core arguments.

joshka··on I built Ponytrail, a local audit trail for AI coding-agent edits
Yuck. Use jj for this instead of a custom thing.
joshka··on Why do commercial spaces sit vacant? (2025)
Yeah, I probably don’t mean fraud in the narrow criminal sense.

The thing that feels fraud-ish to me is that the loss doesn’t just disappear because nobody books it. A huge amount of capital and useful urban land is tied up preserving a fictional valuation and someone is paying for that somewhere.

Maybe it’s not a clean “X stole from Y” thing here, but it still means real businesses are displaced, worse downtowns, and less of the city that could have existed otherwise. I haven't seen this sort of thing as much in Australian cities where I'm from, but have a lot in the US where I live.

So maybe a better way phrasing "fraud on the public commons" is closer to what I mean. Everyone involved is probably acting rationally inside the system. The public still gets stuck living inside the dead space created by the fiction created by it and ends up eating that cost.

joshka··on Agentic coding deserves more than a chat box bolted onto VS Code
Just show me a screenshot please
joshka··on From Chesterton's fence to Chesterton's gap
It's only pressure if you believe the social contract in a PR is that everything that is written is something you're obligated to read / respond to. If you flip that a bit to a PR being the first step in a way of saying "I tried a thing and it worked, what's necessary to make that an actual thing that other can use", then you will sort of land here.

Previously I wrote https://news.ycombinator.com/item?id=48517931

joshka··on Why do commercial spaces sit vacant? (2025)
Sounds like fraud with extra steps.
joshka··on From Chesterton's fence to Chesterton's gap
The counterpoint is that building software is not building a fence. When you create something in software, nothing tangible changes until that's accepted and running on all the places that you deploy to. A PR is just a hey, here's a fence that the contributor built elsewhere that proves that building something like this is possible.

The corollary is design your open source libraries so they're obvious enough that the chesterton's gaps are obvious. Anytime an AI tool submits something that breaks your expectation of things not being necessary it usually highlights that there's a missing gap in the explanation of what is necessary.

joshka··on Weave: Merging based on language structure and not lines
Automated process run into race conditions more often due to their frequency. Humans can do that too, but are less likely to in practice both due to lower frequency and because they carry more awareness of global context that isn't captured in systems that aren't checking for it. The ability of your brain to read and take as context all the pull requests open in a repo that might affect your work.
joshka··on I Am Not a Reverse Centaur
I agree with the core maintainer complaint here: PR slop is bad, and maintainers should not be forced into reviewing code the submitter does not understand.

But I think the answer is not “don’t slop me, all you sloppers.” The better answer is closer to: “what problem were you trying to solve?”

There is no obligation to treat every PR as merge-ready code. A PR can also be a concrete issue report or a proof-of-concept for a bug. It can say: I found a problem, I investigated it, and code was the clearest way to show where I think the issue lives and how it might be addressed. Use or ignore the implementation as you like. Human-language descriptions are not always the best way to communicate something you've already traced through the codebase.

That can be a high-value contribution even if the code itself is not accepted. It moves the conversation from “I want X” to “here is where X touches the codebase, here is a failing case, here is a possible direction, here are the tradeoffs I noticed.”

The social contract should be that the contributor does not dump review debt on the maintainer. Mark it as a prototype. Explain the problem in your own words. Say what you tested. Say what you are unsure about. Be willing to revise or accept that the maintainer may throw the patch away.

But once framed that way, the relevant question is not whether AI was used. It is whether the PR reduces ambiguity or increases burden.

A sloppy PR that demands review is bad. A prototype PR that explains a real problem is often useful.

joshka··on [dead]
This seems like a pretty classic attribution error to me.

The screenshot is funny, and obviously the block is absurd, but the leap from “a safety classifier or routing layer misfired” to “Anthropic is leaning into the nanny state thing” feels like adding a lot of intent that the evidence doesn’t support.

Occam’s razor says this is probably just a dumb false positive somewhere in a safety stack. That’s still worth criticizing, especially because these systems can be brittle and overbroad, but it’s a very different claim from whatever the editorializing is suggesting.

joshka··on H.R. 6028 would fundamentally change the U.S. Copyright Office
But calling them out in a partisan may disincentivize half of the people to understand the issue.
joshka··on The Future of Email
Same - I plugged it into ChatGPT to check if I'd missed something contentful. I hadn't really. Not news, more survey of things that matter a bit. If you know those things already then this is just fluff. Nothing about the future, more just here's some things I like.
joshka··on Ask HN: How do you get into a flow state when using AI to code?
A couple of things to consider:

Start with a set of work that's well specified and reasonably chunked to sizes that make it so that the review parts fit in the gaps of the working chunk and interleave (1-4 tasks of this). While the agent is working on the A task, you're reading the B task, only add a 3rd task if you're waiting on the agent excessively. Give yourself some slack on this to think about side quests (maintenance / tech debt / planning future work to your system etc.)

Make sure the handoffs are reasonably detailed (prompts / AGENTS.md instructions) - make your agents provide more context than normal - make them assume that you don't read all the text they spit out and need to be handed succinct summaries with information that helps reduce cognitive burdens (what I was doing, how I did it, what's next etc.)

It's reasonable to regularly ask the agent what things you've worked on choices made, options considered and discarded, context rehydrating. There's a lot of small tweaks you do when interactive prompting that get lost in a drift rather than captured as a neat single list. Make the agent help track that stuff. (at least prior to shipping, but often in intermediate steps.

Write flows that keep software in a buildable state so you can run it and queue up changes based on what you see. Avoid long periods of broken refactoring (caller code written before callee, deletion before add in a move etc.) Run quick checks (e.g. rust's cargo check) after each change, not at the end.

Correction of agent errors should end up as future steering. If the agent makes a mistake once it's the agents fault, twice it's your fault.

Leave time to stop and evaluate the current state regularly (where are we on the work). It's easy to mistake momentum for progress when you're the human part of an agentic loop.

joshka··on Grit: Rewriting Git in Rust with agents
Please feel free to strongman. Extend the argument until it hits a point of non-triviality and then apply reasoning.
joshka··on Grit: Rewriting Git in Rust with agents
You've read books and they are in your brains corpus. You only infringe copyright if you reproduce the same actual words from the books in your memory (and then do infringing acts defined by copyright laws with that output).

Here that's not happening. The code being produced by the LLM is Rust, not C.

joshka··on Grit: Rewriting Git in Rust with agents
> There is no other behavioral description that would reproduce all needed functionality.

Tests often are exactly the information necessary to understand exactly what the output should be. See https://github.com/git/git/blob/master/t/t0000-basic.sh for an example of how detailed these tests are.

It would be reasonable to point an LLM at these and use them with a basic knowledge of git to produce a rust version of git in a non-infringing manner.

If you did this manually it would take a long time.

joshka··on Grit: Rewriting Git in Rust with agents
Repetition isn't really a factor in deciding whether something is infringing or not - check the copyright law in your jurisdiction. Here if you look specifically at what an LLM's sampling stage is doing, it's choosing non infringing tokens (i.e. rust source code) over infringing ones (i.e. C source code). So it's making an intentional choice to do something similar rather than creating something that has the same expression. That doesn't seem like it's copyright infringement to me.
joshka··on Grit: Rewriting Git in Rust with agents
I'd challenge you here to think about this in terms of the legal aspects rather than reaching specifically for similarities as similar is often meaningless in the law or contracts when specific acts are codified rather than generalized ones.

I'd say what we're talking about here is probably a fair bit different to modding a game in most aspects.

joshka··on Grit: Rewriting Git in Rust with agents
> [US jurisdiction]: Anything in the result written by the LLM can not be copyright by anyone.

This is a bit stronger than the actual report where this has been discussed finds. See part 2 in https://www.copyright.gov/ai/ for details, but TL;DR, parts where humans have control over the expression may be copyrightable. But working out which parts those are is likely a difficult question (would likely require proof of provenance across many of those LLM sessions)

joshka··on Grit: Rewriting Git in Rust with agents
You're recalling it right, but there's a nice quote from Judge Alsup in that case that talks about this exact situation:

> “So long as the specific code used to implement a method is different, anyone is free under the Copyright Act to write his or her own code to carry out exactly the same function or specification...”

Here given that this is rust and the original expression is C, the implementations cannot be the same by definition.

joshka··on Grit: Rewriting Git in Rust with agents
> test_sum is assumedly relatively trivial. So as a lay person I’d expect some sort of obviousness test to apply. Like so much of the stuff in the Google/Oracle lawsuit.

Feel free to extrapolate to the threshold where it's not and at that point apply.

> you’re really having to duplicate the actual git internals

Copyright covers the expression, not the method. So the Rust function:

    fn sum(a: u8, b: u8) {
        a + b
    }
is distinct from the C function:

    int sum(int a, int b) 
    {
        return a + b;
    }
joshka··on Grit: Rewriting Git in Rust with agents
By definition a test suite is about testing interoperability with the test suite. An HTTP test suite should likely test for whether response code 418 is implemented a particular way and while humorous it would still be an interop test no?
joshka··on Grit: Rewriting Git in Rust with agents
> Doesn't infringe upon copyright period, because there's no creative element in that work.

There's likely a threshold at some point. It's helpful to look at a minima and then continue from there though.

I'm curious if there's case law that supports your assertions here?

joshka··on Grit: Rewriting Git in Rust with agents
This is the exact thing I'm not sure about. See https://news.ycombinator.com/item?id=48470397 where I posit a simpler question: if a `test_sum()` function is copyrighted, does writing a `sum(a, b)` function infringe on the copyright of the software product that `test_sum()` is a part of. I'd say no. There's another part of the GPL that applies here:

> A compilation of a covered work with other separate and independent works, which are not by their nature extensions of the covered work, and which are not combined with it such as to form a larger program, in or on a volume of a storage or distribution medium, is called an “aggregate” if the compilation and its resulting copyright are not used to limit the access or legal rights of the compilation's users beyond what the individual works permit. Inclusion of a covered work in an aggregate does not cause this License to apply to the other parts of the aggregate.

So assuming that sum(a, b) is non-infringing and not combined to form a larger program (i.e. the tests aren't compiled into the grit code), then the GPL explicitly doesn't apply to this use

← PreviousPage 5 of 34Next →