How does this work exactly? It doesn't. It's a misunderstanding of public debt.

When you say stops buying US bonds, you're talking about the secondary market for US government bonds right - because in practice, contrary to the econ textbooks and common understanding, only a small number of institutions are allowed to purchase them in the primary market, not only that but these purchasers are compelled by law to continue buying them, to continue bidding for them at a fair price, and if they don't have the reserves to buy them then these purchasers will be given the reserves to continue to buy them. The entire premise of the argument falls apart as soon as you step away from the econ model and look at the legislation governing what actually happens by law.

You know your system better than me for sure, a random commenter on a website :-D your comment just shocked me out of my daze enough for my brain to say "but I always move the record to another table rather than soft delete" and i felt compelled to give unsolicited and likely wrong opinion.

Is that likely? History says it's inevitable, but timeframe is an open question.

Here in the UK (where i also have free tesla repair manual access) i have to pay a daily rate (there are annual subscriptions available) for other marques and i would say it's not cheap.

For example, ford charges me £20/hour or £75/day for access to manuals, wiring diagrams, online connected diagnostics (which sounds more impressive than it is, the UI will show vehicle status like fuel tank level or error codes reported by the various ECUs, without physically connecting to the vehicle, i.e. it's done over the vehicle telemetry link), and the ability to connect via a data link connector device for diagnostics and some reflashing activities. Security activities like key coding require a further (chargeable) registration).

The same setup is available by at least VAG, BMW and Fiat Chrysler (the latter has an annoying extra device registration step the others don't). All chargeable.

No i'd push back on this because the entire workshop manual is available for free without even registration required. You can literally google and land in the relevant sections and it is of a far higher quality than ford, VAG or bmw as three examples i'm pretty familiar with. I haven't seen the John Deere stuff.

Tesla does have "special tools" for some repair procedures, a practice as old as the auto industry but they don't rely on them to the same extent as BMW for example. Anecdotally, the special tools i'm aware of are genuinely useful - for example, the tool for disconnecting seatbelt anchors saves time vs the traditional bolt - where special tools on other marques are often clearly to workaround a failure of packaging or engineering resulting in tight access for a regular tool.

Their online API access is a little bit annoying, or at least unfriendly to casual home user, specifically the workflow to register an OIDC client, but not insurmountable.

If embedded Ghostty owns it, now i have to have some kind of workaround to instrument what's happening inside the terminal - signals, stdout/stderr events, return code etc.

If my parent agent-manager app owns it, now i don't have the nice clean small interface to ghostty (i'm a fan of John Ousterhout style narrow but deep interfaces, pulling complexity down rather than pushing up to parent).

Not sure if any other ghostty embedders might have advice. It's on my todo list to task a an agent to "gh repo clone" a few ghostty using shells and report on their arch.

I used to be on that side of the argument - clearly code is more precise so it MUST be simpler than wrangling with the uncertainty of prose. But precision isn't the only factor in play.

The argument here is that essential complexity lives on and you can only convert between expressions of it - that is certainly true but it's is overlooking both accidental complexity and germane complexity.

Specs in prose give you an opportunity to simplify by right-sizing germane complexity in a way that code can't.

You might say "well i could create a library or a framework and teach everyone how to use it" and so when we're implementing the code to address the essential complexity, we benefit from the germane complexity of the library. True, but now consider the infinite abstraction possible in prose. Which has more power to simplify by replacing essential complexity with germane complexity?

Build me a minecraft clone - there's almost zero precision here, if it weren't for the fact that word minecraft is incredibly load bearing in this sentence, then you'd have no chance of building the right thing. One sentence. Contrast with the code you'd have to write and read to express the same.

#!/usr/bin/env bash # agent-lib.sh — shared plumbing for all claude -p agents

AGENTS_DIR="${AGENTS_DIR:-$HOME/Code/github.com/craigjperry2/tiny-agents}" SKILLS_DIR="$AGENTS_DIR/skills" CLAUDE_OPTS="${CLAUDE_OPTS:-}"

# Build a system prompt by concatenating skill files # Usage: load_skills core/unix-output.md domain/git.md output/plain-text.md load_skills() { local combined="" for skill in "$@"; do local path="$SKILLS_DIR/$skill" if [[ -f "$path" ]]; then combined+=$'\n\n'"$(cat "$path")" else echo "[agent-lib] WARNING: skill not found: $skill" >&2 fi done echo "$combined" }

# Core invocation: reads stdin, prepends system prompt, calls claude -p # Usage: run_agent [extra claude opts...] run_agent() { local system_prompt="$1" shift local stdin_content stdin_content=$(cat) # buffer stdin

    if [[ -z "$stdin_content" ]]; then
        echo "[agent] ERROR: no input on stdin" >&2
        exit 1
    fi

    # Combine system prompt with stdin as user message
    printf '%s' "$stdin_content" \
        | claude -p \
            --system-prompt "$system_prompt" \
            --output-format text \
            $CLAUDE_OPTS \
            "$@"

# Run agent then pipe through a guard # Usage: run_agent_guarded run_agent_guarded() { local guard="$1" shift local system_prompt="$1" shift

    local output
    output=$(run_agent "$system_prompt" "$@")
    local agent_exit=$?

    if [[ $agent_exit -ne 0 ]]; then
        echo "$output"
        exit $agent_exit
    fi

    # Pass through guard
    echo "$output" | "$AGENTS_DIR/guards/$guard"
    exit $?

# For structured output: run agent then validate with jq run_json_agent() { local system_prompt="$1" shift run_agent "$system_prompt" --output-format text "$@" | guard-json-valid }

    Context: You are working with Git repositories.
    - Commit messages follow Conventional Commits: type(scope): description
    - Types: feat, fix, docs, refactor, test, chore, ci, perf
    - Subject line max 72 chars, imperative mood, no trailing period
    - Reference issue numbers when relevant

    $ git diff HEAD~1 | bin/ai-commit-msg
    fix(guards): pass input to claude and tighten verdict handling

    - claude takes a -p option
    - i have a bunch of tiny scripts, each script is an agent but it only does one tiny task
    - scripts can be composed in a unix pipeline

    $ git diff --staged | ai-commit-msg | git commit -F -

    #!/usr/bin/env bash
    # ai-commit-msg: stdin=git diff, stdout=conventional commit message
    # Usage: git diff --staged | ai-commit-msg
    set -euo pipefail
    source "${AGENTS_DIR:-$HOME/.agents}/lib/agent-lib.sh"
    
    SYSTEM=$(load_skills \
        core/unix-output.md \
        core/be-concise.md \
        domain/git.md \
        output/plain-text.md)
    
    SYSTEM+=$'\n\nTask: Given a git diff on stdin, output a single conventional commit message. One line only.'
    
    run_agent "$SYSTEM"

That description is NOT coding, coding is a subset of that.

Coding comes once you know what you need to build, coding is the process of you expressing that in a programming language and as you do so you apply all your knowledge, experience and crucially your taste, to arrive at an implementation which does what's required (functionally and non-functionally) AND is open to the possibility of change in future.

Someone else here wrote a great comment about this the other day and it was along the lines of if you take that week of work described in the GP's comment, and on the friday afternoon you delete all the code checked in. Coding is the part to recreate the check in, which would take a lot less than a week!

All the other time was spent turning you into the developer who could understand why to write that code in the first place.

These tools do not allow you to skip the process of creation. They allow you to skip aspects of coding - if you choose to, they can also elide your tastes but that's not a requirement of using them, they do respond well to examples of code and other directions to guide them in your tastes. The functional and non-functional parts they're pretty good at without much steering now but i always steer for my tastes because, e.g. opus 4.5 defaults to a more verbose style than i care for.

There are cases where you need more than htmx / datastar, but i like the explicit calling out of when these boundaries occur (e.g. you've exceeded what "islands" can give you), and i like the gravitational pull to lower levels.

I'm accountable for the code i push to production. I have all the power and agency in this scenario, so i am the right person to be accountable for what's in my PR / CL.

I purchase a treasury. I have zero product, zero dollars and one treasury.

At some point in future i have zero product, maybe 12 dollars and zero treasuries. Presumably i now either repeat the cycle or use my winnings to spend on us output.

GP’s version checks out, your assertion about dollars staying abroad doesnt track? What am i misunderstanding - How did these dollars get abroad, how did they repatriate to buy treasuries, how did a treasury become a reserve, how did the dollars still exist abroad after being exchanged for treasuries?

Is this true?

If an EV were 30% heavier than an ICE, would it produce 30% more tyre wear emissions? Or would it produce more or less than 30%? Is the primary factor in tyre wear weight and is the relationship linear?

The types of tyres appear to be quite different, the EVs seem to have smaller contact patches (narrower wheels) and they're made of different "less grippy" compounds that drag less. Does this change the equation at all?