sheept

This might be operating system/browser-specific. On Windows Chrome, shift-click opens in new window, ctrl in new tab, and alt downloads the link.

I disagree: this is not unlike including the schema in the JSON itself. This should be handled by the apps themselves, since they would have to know what the keys mean regardless.

If you do want the interchange format to be the one deserializing into specific runtime data structures, use YAML. YAML's tag syntax allows you to run arbitrary code inside YAML, which can be used for what you want.

I think that it's nice it's explicit that the method returns the current instant, rather than some other zero value.

There's also other methods that return other types, like

    const now = Temporal.Now.instant()

which isn't as bad.

One could argue that the ugliness of the API intentionally reveals the ugliness of datetime. It forces you to really think about what you mean when you want "the current date time," which I think is one of the goals of the API.

I'm skeptical of this both because this post was largely speculation, and because I would argue Meta has no need to record every private moment for training data.

After all, as the owner of massive social networks, they already have plenty of cleaner, public data that has way more associated labels, like captions, comments, viewer engagement data, and that way they would avoid another data scandal. It's like how people think the Facebook app is secretly recording their microphone, even though their behavior is already obvious through just their and their friends' app engagement. The point of the glasses is to share your footage online, so the recordings would end up public anyways without Meta needing to do anything sneaky.

Probably browser extensions operating on React apps

To be fair, there's little stopping you from putting the button action in its onclick attribute.

I guess the stylistic choice of separating content, style, and interactivity eventually became a convention to keep JavaScript isolated from HTML, but nowadays with Tailwind and HTMX, it does seem like at least some developers want everything in HTML, for the strengths you mentioned.

The meeting isn't the hard part—after all, shareholder meetings have huge audiences too. Enforcing mandatory attendance for myriads of employees is the hard part, so it's more likely mandatory in name only.

ctrl+G may also mean "find next" on Windows (e.g. in Chrome), so it's not particularly obscure.

At least in VS Code, ctrl+G on Mac is the shortcut for "goto line" (but yes, cmd+G is "find next")

If you let an LLM generate it (e.g. Claude's /init), it'll be a lot more verbose then it needs to be, which wastes tokens and deemphasizes any project-specific preferences you actually want the agent to heed.

I guess a business reason for scroll lock in the TV UIs is that it immediately shows more recommendations as you scroll right, which I suppose could increase engagement.

crypto.randomUUID()?

Needs to be a fork.

Related: https://trufflesecurity.com/blog/anyone-can-access-deleted-a...

Claude will load the name and description of each enabled skill into context at startup[0]; the LLM needs to know what it can invoke, after all. It's negligible for a few skills, but a hundred skills will likely have some impact, e.g. deemphasizing other skills by adding noise.

[0]: https://platform.claude.com/docs/en/agents-and-tools/agent-s...

Sure, but the post itself brags,

> gws ships 100+ SKILL.md files

Which must altogether be hundreds of lines of YAML frontmatter polluting your context.

This feels completely speculative: there's no measure of whether this approach is actually effective.

Personally, I'm skeptical:

- Having the agent look up the JSON schemas and skills to use the CLI still dumps a lot of tokens into its context.

- Designing for AI agents over humans doesn't seem very future proof. Much of the world is still designed for humans, so the developers of agents are incentivized to make agents increasingly tolerate human design.

- This design is novel and may be fairly unfamiliar in the LLM's training data, so I'd imagine the agent would spend more tokens figuring this CLI out compared to a more traditional, human-centered CLI.

I feel like this makes sense for a platform that targets teens. Plus, I wouldn't trust TikTok to implement E2E encryption properly—who knows what they've snuck into their client.

Somewhat relatedly, GitHub Pages does support using URL-encoded newline characters %0A to reference file names with newlines,[0] but GitHub itself will omit the file from the web UI's tree view.

[0]: https://sheeptester.github.io/hello-world/test/%20%0A%20%0A/...

In my CLAUDE.md, I have Claude include all new prompts verbatim in the commit message body.

While I haven't used Claude long enough to need my prompts, I would appreciate seeing my coworkers' prompts when I review their LLM-generated code or proposals. Sometimes it's hard to tell if something was intentional that the author can stand behind, or fluff hallucinated by the LLM. It's a bit annoying to ask why something suspicious was written the way it is, and then they go ahead and wordlessly change it as if it's their first time seeing the code too.

Sure, the syntax is unique, but it's fairly easy to get over that. I guess I'm comparing to Rust, where not only is syntax different, but data structures like a tree with parent references aren't as straightforward (nor idiomatic), and there's a lot more explicit methods that requires knowing which are important and which are just noise (e.g. unwrap, as_ref).

I would argue that after a short tutorial on basic syntax, it's easier for a Python/JavaScript programmer to understand Go code than Rust.

I agree, its strength (beyond goroutines) is that anyone who knows one of the popular languages (Python, Java, etc) can easily translate their idioms and data structures to Go, and the code would remain easy to read even without much Go experience. That's probably one reason why the TypeScript compiler team chose Go.

But this makes the language feel like Python, in some ways. Besides nil, the lack of expressivity in its expressions makes it more idiomatic to write things imperatively with for loops and appending to slices instead of mapping over the slice. Its structurally typed interfaces feel more like an explicit form of duck typing.

Also, Go has generics now, finally.

Is the submission's title "AWS data center hit by Iran" editorialized? Neither the article nor AWS claim it was Iran's doing, it's only heavily implied, and the article's title would've sufficed

If a malicious website wanted to copy a blog's website to put ads on it, they already can just copy it outside of the browser on their end, which has the "benefit" of preventing the original blog from taking the post down.

CORS also doesn't prevent a popular website with a personal vendetta[0] against a blogger from DDOSing the blog with their visitors, since CORS doesn't block requests from being sent.

For a purely static website, there shouldn't be any risk from enabling CORS.

[0]: https://news.ycombinator.com/item?id=46624740

I wonder what limitations Google is planning with this API to avoid misuse[0] (from the agent/Google's perspective).

A website that doesn't want to be interfaced by an agent (because they want a human to see their ads) could register bogus but plausible tools that convince the agent that the tool did something good. Perhaps the website could also try prompt injecting the agent into advertising to the user on the website's behalf.

[0]: Beyond just hoping the website complies with their "Generative AI Prohibited Uses Policy": https://developer.chrome.com/docs/ai/get-started#gemini_nano...

I agree, it's always been unsettling to see any[] on hover, even though it gets typed in the end.

I think one reason might be to allow the type to be refined differently in different code paths. For example:

    function x () {
        let arr = []
        if (Math.random() < 0.5) {
            arr.push(0)
            return arr
        } else {
            arr.push('0')
            return arr
        }
    }

In each branch, arr is typed as number[] and string[], respectively, and x's return type is number[] | string[]. If it decided to retroactively infer the type of arr at declaration, then I'd imagine x's return type would be the less specific (number | string)[].

XML is a bit more special/first class to Claude because it uses XML for tool calling:

    <antml:invoke name="Read">                                                    
      <antml:parameter name="file_path">/path/to/file</antml:parameter>             
      <antml:parameter name="offset">100</antml:parameter>                          
      <antml:parameter name="limit">50</antml:parameter>                            
    </antml:invoke>

I'm sure Claude can handle any delimiter and pseudo markup you throw at it, but one benefit of XML delimiters over quotation marks is that you repeat the delimiter name at the end, which I'd imagine might help if its contents are long (it certainly helps humans).

This method of copying an LLM-generated summary of your preferences into Claude memory feels similar to their recommendation to use /init to generate a CLAUDE.md based on the project, which recent research[0] suggests may be counterproductive.

I would assume both Claude memory and CLAUDE.md work best when they're carefully curated, only containing what you've found yourself having to repeat.

[0]: https://arxiv.org/abs/2602.11988

I think from their end, they see a lot more malicious users (e.g. spam accounts) that it's not worth providing a gentle warning before a ban. There might've been thousands more accounts created for Chinese companies for distillation[0], that Google didn't think of/weren't able to initially distinguish genuine user accounts just using a third party tool on their Antigravity token.

Like in a similar vein, Instagram sometimes randomly bans genuine users without appeal, probably because they deal with thousands more spam accounts that don't deserve a warning/appeals process.

[0] Like as Anthropic reported: https://www.anthropic.com/news/detecting-and-preventing-dist...

It's not common, but there are web APIs where you await a promise that already exists as a property, rather than being returned from a function call, like

    await document.fonts.ready

    device.lost.then(() => {
      console.log('WebGPU device lost :(')
    })

I feel like this isn't confusing if you know how promises work, but maybe it can be confusing for someone coming from Python/Rust, where async functions don't evaluate until their futures are awaited.

Yes, Rust does not guarantee that it'll prevent memory leaks. But the design of the language does make it harder for you (and your collaborators/dependencies) to accidentally leak memory compared to, say, C++.

It appears to be part of the font[0]. It looks a bit weird, but display fonts usually can get away with being more eccentric.

[0]: https://fonts.google.com/specimen/Syne