papetoast’s Shortforms
Explicitly welcomed:
Help to develop the ideas
Link to related concepts/pre-existing posts
Writing critique of everything
Explicitly welcomed:
Help to develop the ideas
Link to related concepts/pre-existing posts
Writing critique of everything
In my life I have never seen a good one-paragraph[1] explanation of backpropagation so I wrote one.
The most natural algorithms for calculating derivatives are done by going through the expression syntax tree[2]. There are two ends in the tree; starting the algorithm from the two ends corresponds to two good derivative algorithms, which are called forward propagation (starting from input variables) and backward propagation respectively. In both algorithms, calculating the derivative of one output variable y1 with respect to one input variable x1 actually creates a lot of intermediate artifacts. In the case of forward propagation, these artifacts means you get δynδx1 for ~free, and in backward propagation you get δy1δxn for ~free. Backpropagation is used in machine learning because usually there is only one output variable (the loss, a number representing difference between model prediction and reality) but a lot of input variables (parameters; in the scale of millions to billions).
This blogpost by Christopher Olah has the clearest multi-paragraph explanation. Credits for the image too.
Actually a directed acyclic graph for multivariable vector-valued functions like f(x,y)=(2x+y, y-x), or if you do Common Subexpression Elimination in the syntax tree (as is done for the b node in the image). For simplicity I pretend that it is a tree.
Presumably you meant to say something else here than to repeatδyiδx1twice?Edit: Oops, I now see. There is a switched i. I did really look quite carefully to spot any difference, but I apparently still wasn’t good enough. This all makes sense now.
It is hard to see, changed to n.
I could barely see that despite always using a zoom level of 150%. So I’m sometimes baffled at the default zoom levels of sites like LessWrong, wondering if everyone just has way better eyes than me. I can barely read anything at 100% zoom, and certainly not that tiny difference in the formulas!
Our post font is pretty big, but for many reasons it IMO makes sense for the comment font to be smaller. So that plus LaTeX is a bit of a dicey combination.
Raw feelings: I am kind of afraid of making reviews for LW. The writing prompt hints very high effort thinking. The vague memory of other people’s reviews also feel high effort. The “write a short review” ask doesn’t really counter this at all.
Thank you!
Would it help if the prompt read more like a menu?
Yeah, and perhaps a couple examples of bare minimum / average / high quality review in the main post
On thing to note is that “short reviews” in the nomination phase are meant to be basically a different type of object than “effort reviews.” Originally we actually had a whole different data-type for them (“nominations”), but it didn’t seem worth the complexity cost.
And then, separately: one of the points of the review is just to track “did anyone find this actually helpful?” and a short review that’s like “yep, I did in fact use this concept and it helped me, here’s a few details about it” is valuable signal.
Drive by “this seems false, because [citation]” also good.
It is nice to do more effortful reviews, but I definitely care about those types of short reviews.
It is sad and annoying that if you do a mediocre job (according to the receiver), doing things even for free (volunteer work/gifting) can sabotage the receiver along the dimension you’re supposedly helping.
This is super vague the way I wrote it, so examples.
Example 1. Bob wants to upgrade and buy a new quality headphone. He has a $300 budget. His friend Tim not knowing his budget, bought a $100 headphone for Bob. (Suppose second-handed headphones are worthless) Now Bob cannot just spend $300 to get a quality headphone. He would also waste Tim’s $100 which counterfactually could have been used to buy something else for Bob. So Bob is stuck with using the $100 headphone and spending the $300 somewhere else instead.
Example 2. Andy, Bob, and Chris are the only three people who translates Chinese books to English for free as a hobby. Because there are so many books out there, it is often not worth it to re-translate a book even if the previous one is bad, because spending that time to translate a different book is just more helpful to others. Andy and Bob are pretty good, but Chris absolutely sucks. It is not unreadable, but they are just barely better than machine translation. Now Chris has taken over to translate book X, which happens a pretty good book. The world is now stuck with Chris’ poor translation on book X with Andy and Bob never touching it again because they have other books to work on.
Allocation of blame/causality is difficult, but I think you have it wrong.
No. TIM wasted $100 on a headset that Bob did not want (because he planned to buy a better one). Bob can choose whether to to hide this waste (at a cost of the utility loss by having $300 and worse listening experience, but a “benefit” of misleading Tim about his misplaced altruism), or to discard the gift and buy the headphones like he’d already planned (for the benefit of being $300 poorer and having better sound, and the cost of making Tim feel bad but perhaps learning to ask before wasting money).
Umm, here I just disagree. The world is no worse off for having a bad translation than having no translation. If the bad translation is good enough that the incremental value of a good translation doesn’t justify doing it, then that is your answer. If it’s not valuable enough to change the marginal decision to translate, then Andy or Bob should re-translate it. Either way, Chris has improved the value of books, or has had no effect except wasting his own time.
True in my example. I acknowledge that my example is wrong and should have been more explicit about having an alternative. Quoting myself from the comment to Vladimir_Nesov:
Anyways, the unwritten thing is that Bob care about having a quality headphone and a good pair of shoes equally. So given that he already has an alright headphone, he would get more utility by buying a good pairs of shoes instead. It is essentially a choice between (a) getting a $300 headphone and (b) getting a $100 headphone and a $300 pair of shoes.
I do accept this as the rational answer, doesn’t mean it is not irritating. If A (skillful translator) cares about having a good translation of X slightly more than Y, and B (poor translator) cares about Y much more than X. If B can act first, he can work on X and “force” A (via expected utility) to work on Y. This is a failure of mine to not talk about difference in preference in my examples and expect people to extrapolate and infer it out.
That’s a form of sunk cost fallacy, a collective “we’ve sacrificed too much to stop now”.
That doesn’t follow, the other books would’ve also been there without existence of this book’s poor translation. If the poor translation eats some market share, so that competing with it is less appealing, that could be a valid reason.
This is a tangent, but Sunk cost fallacy is not really a fallacy most of the time, because spending more resources beforehand really increases the chance of “success” most of the time. For more: https://gwern.net/sunk-cost
I am trying to pinpoint the concept of “A doing a mediocre job of X will force B to rationally do Y instead of X, making the progress of X worse than if A had not done anything”. The examples are just examples that hopefully helps you locate the thing I am handwaving at. I do not try to make them logically perfect because that would take too much time.
Anyways, the unwritten thing is that Bob care about having a quality headphone and a good pair of shoes equally. So given that he already has an alright headphone, he would get more utility by buying a good pairs of shoes instead. It is essentially a choice between (a) getting a $300 headphone and (b) getting a $100 headphone and a $300 pair of shoes. Of course there are some arguments about preference, utility != dollar amount or something along those lines. But (b) is the better option in my constructed example to show the point.
Let me know if I still need to explain example 2
The decision to go on with the now-easier rest-of-the-plan can be correct, it’s not the case that all plans must always be abandoned on the grounds of “sunk cost fallacy”. The fallacy is when the prior spending didn’t actually secure the rest of the current plan as the best course of action going forward. Alternatives can emerge that are better than continuing and don’t make any use of the sunk resources.
It sure can! I think we are in agreement on sunk cost fallacy. I just don’t think it applies to example 1 because there exists alternatives that can keep the sunk resources. Btw this is why my example is on the order of $100, at this price point you probably have a couple alternative things to buy to spend the money.
What matters is if those alternatives are better (and can be executed on, rather than being counterfactual). It doesn’t matter why they are better. Being better because they made use of the sunk resources (and might’ve become cheaper as a result) is no different from being better for other reasons. The sunk cost fallacy is giving additional weight to the alternatives that specifically use sunk resources, instead of simply choosing based on which alternatives are now better.
Again, seems like we are in agreement lol. I agree with what you said and I meant that, but tried to compress it into one sentence and failed to communicate.
In both cases one particular project was harmed but the sum total of projects was helped.
(I need to defend the sad and the annoying in two separate parts)
Yes, and but sometimes that is already annoying on its own (Bob is not perfectly rational and sometimes he just really want the quality headphone, but now math tells Bob that Tim gifting him that headphone means he would have to wait e.g. ~2 years before it is worth buying a new one). Of course Bob can improve his life in other ways with his saved money, but still, would be nice if you can just ask Tim to buy something else if you had known.
Sometimes increasing sum(projects) does not translate directly to increasing utility. This is more obvious in real life scenarios where actors are less rational and time is a real concept. The sad thing happens when someone with good intention but with poor skill (and you don’t know they are that bad) signing up to a time-critical project and failing/doing sub-par
Seems like the problem is that in real life people are not perfectly rational, and also they have an instinct to reciprocate when they receive a gift (at least by saying “thank you” and not throwing the gift away).
In a world where Bob is perfectly rational and Tim has zero expectations about his gift, the situation is simple. Previously, Bob’s choices were “spend $300 on good headphone”, “spend $100 on bad headphone and $200 on something else”, and “spend $300 on something else”. Tim’s action replaced the last two options with a superior alternative “use Tim’s headphone and spend $300 on something else”. Bob’s options were not made worse.
But real people are not utility maximizers. We instinctively try to choose a locally better option, and how we feel about it depends on what we perceive as the baseline. Given the choice between 10 utilons and 3 utilons, we choose 10 and feel like we just “gained 7 utilons”. Given the choice between 10 utilons and 9 utilons, we choose 10 again, but this time we feel like we just “gained 1 utilon”. Given the choice between 10 utilons and 10 utilons of a different flavor, we might feel annoyed about having to choose.
Also, if Tim expects Bob to reciprocate in a certain way, the new options are not strictly better, because “spend $300 on good headphone” got replaced by “spend $300 on good headphone, but owe Tim a favor for giving me the $100 headphone I didn’t use”.
Yes!
https://www.lesswrong.com/posts/dRTj2q4n8nmv46Xok/cost-not-sacrifice?commentId=zQPw7tnLzDysRcdQv
There are infinite things to be sad and annoyed by, should you choose to focus on those. :) I’d rather focus on the world as a whole being made better in your examples.
One of my pet peeves is that the dropcaps in gwern’s articles are really, really offputting and most of the time unrecognizable, even though gwern’s articles are so valuable that he has a lot of weirdness points in my head and I will still read his stuff regardless. Most of the time I just guess the first letter.
I hate dropcaps in general, but gwern’s is the ugliest I have came by.
image source: https://gwern.net/everything
Collecting occurrences of people complaining about LW
Skimmed twitter.search(
lesswrong -lesswrong.com -roko -from:grok -grok since:2026-01-01 until:2026-01-28)negative
https://x.com/fluxtheorist/status/2015642426606600246
https://x.com/repligate/status/2011670780577530024 compares pedantic terminology complaint by peer reviewer of some paper to LW.
https://x.com/kave_rennedy/status/2011131987168542835
https://x.com/Kaustubh102/status/2010703086512378307 first post rejected; claims not written by LLM, but rejection may be because “you did not chat extensively with LLMs to help you generate the ideas.”
positive
During my search, it was hard to ignore the positive comments. So here are some examples of positive comments too.
https://x.com/boazbaraktcs/status/2016403406202806581
https://x.com/joshycodes/status/2009423714685989320
https://x.com/TutorVals/status/2008474014839390312
otherwise interesting
https://x.com/RyanPGreenblatt/status/2008623582235242821
https://x.com/nearcyan/status/2010945226114994591
Hope you’re ready to write 10,000 replies ;-)
https://x.com/eris_nerung/status/2016317953264807947
https://news.ycombinator.com/item?id=44317180 (much much more in the discussions)
A decision theorist walks into a seminar by Jessica Hullman
What coding prompt (AGENTS.md / cursor rules / skills) do you guys use? It seems exceedingly difficult to find good ones. GitHub is full of unmaintained & garbage `awesome-prompts-123` repos. I would like to learn from other people’s prompt to see what things AIs keep getting wrong and what tricks people use.
Here are mine for my specific Python FastAPI SQLAlchemy project. Some parts are AI generated, some are handwritten, should be pretty obvious. This is built iteratively whenever the AI repeated failed a type of task.
AGENTS.md
# Repository Guidelines
## Project Overview
This is a FastAPI backend for a peer review system in educational contexts, managing courses, assignments, student allocations, rubrics, and peer reviews. The application uses SQLAlchemy ORM with a PostgreSQL database, following Domain-Driven Design principles with aggregate patterns. Core domain entities include Course, Section, Assignment, Allocation (peer review assignments), Review, and Rubric with associated items.
This project is pre-alpha, backwards compatibility is unimportant.
## General Principles
- Don’t over-engineer a solution when a simple one is possible. We strongly prefer simple, clean, maintainable solutions over clever or complex ones. Readability and maintainability are primary concerns, even at the cost of conciseness or performance.
- If you want exception to ANY rule, YOU MUST STOP and get explicit permission from the user first. BREAKING THE LETTER OR SPIRIT OF THE RULES IS FAILURE.
- Work hard to reduce code duplication, even if the refactoring takes extra effort. This includes trying to locate the “right” place for shared code (e.g., utility modules, base classes, mixins, etc.), don’t blindly add the helpers to the current module.
- Use Domain-Driven Design principles where applicable.
## SQLAlchemy Aggregate Pattern
We use a parent-driven (inverse) style for DDD aggregates where child entities cannot be constructed with a parent reference.
**Rules:**
- Child→parent relationships must have `init=False` (e.g., `Allocation.assignment`, `Review.assignment`, `RubricItem.rubric`, `Section.course`)
- Parent→child collections must have `cascade=”all, delete-orphan”, single_parent=True, passive_deletes=True`
- Always use explicit `parent.children.append(child)` after creating the child entity
- Never pass the parent as a constructor argument: `Child(parent=parent)` ❌ → `child = Child(); parent.children.append(child)` ✅
Additional rules (aggregate-root enforcement):
- Never manually assign parent foreign keys (e.g., `child.parent_id = parent.id`).
- Do not perform cross-parent validations inside child methods.
- Let SQLAlchemy set foreign keys via relationship management (append child to parent collection).
- Enforce all aggregate invariants at the aggregate root using object-graph checks (e.g., `section in course.sections`).
Service layer patterns:
- **Mutations** (create, update, delete): Always return the aggregate root.
- **Queries** (get, list): May return child entities directly for convenience, especially when the caller needs to access a specific child by ID.
## Code Style
- 120-character lines
- Type hint is a must, even for tests and fixtures!
- **Don’t use Python 3.8 typings**: Never import `List`, `Tuple` or other deprecated classes from `typing`, use `list`, `tuple` etc. instead, or import from `collections.abc`
- Do not use `from __future__ import annotations`, use forward references in type hints instead.
- `TYPE_CHECKING` should be used only for imports that would cause circular dependencies. If you really need to use it, then you should import the submodule, not the symbol directly, and the actual usages of the imported symbols must be a fully specified forward reference string (e.g. `a.b.C` rather than just `C`.)
- Strongly prefer organizing hardcoded values as constants at the top of the file rather than scattering them throughout the code.
- Always import at the top of the file, unless you have a very good reason. (Hey Claude Opus, this is very important!)
## Route Logging Policy
- FastAPI route handlers only log when translating an exception into an HTTP 5xx response. Use `logger.exception` so the stack trace is captured.
- Never log when returning 4xx-class responses from routes; those are user or client errors and can be diagnosed from the response body and status code alone.
- Additional logging inside services or infrastructure layers is fine when it adds context, but avoid duplicating the same exception in multiple places.
**Why?**
- 5xx responses indicate a server bug or dependency failure, so capturing a single structured log entry with the traceback keeps observability noise-free while still preserving root-cause evidence.
- Omitting logs for expected 4xx flows prevents log pollution and keeps sensitive user input (which often appears in 4xx scenarios) out of centralized logging systems.
- Using `logger.exception` standardizes the output format and guarantees stack traces are emitted regardless of the specific route module.
### Using deal
We only use the exception handling features of deal. Use `@deal.raises` to document expected exceptions for functions/methods. Do not use preconditions/postconditions/invariants.
Additionally, we assume `AssertionError` is never raised, so `@deal.raises(AssertionError)` is not allowed.
Use the exception hierarchy defined in exceptions.py for domain and business logic errors. For Pydantic validators, continue using `ValueError`.
## Documentation and Comments
Add code comments sparingly. Focus on why something is done, especially for complex logic, rather than what is done. Only add high-value comments if necessary for clarity or if requested by the user. Do not edit comments that are separate from the code you are changing. NEVER talk to the user or describe your changes through comments.
### Google-style docstrings
Use Google-style docstrings for all public or private functions, methods, classes, and modules.
For functions (excluding FastAPI routes), always include the “Args” sections unless it has no arguments. Include “Raises” if anything is raised. Include “Returns” if it returns a complex type that is not obvious from the function signature. Optionally include an “Examples” section for complex functions.
FastAPI Routes: Use concise summary docstrings that describe the business logic and purpose. Omit Args/Raises/Returns sections since these are documented via decorators (response_model, responses), type hints, and Pydantic models. The docstring may appear in generated API documentation.
For classes, include an “Attributes:” section if the class has attributes. Additionally, put each attribute’s description in the “docstring” of the attribute itself. For dataclasses, this is a triple-quoted string right after the field definition. For normal classes, this is a triple-quoted string in either the class body or the first appearance of the attribute in the `__init__` method, depending on where the attribute is defined.
For modules, include a brief description at the top.
Additionally, for module-level constants, include a brief description right after the constant definition.
### Using a new environmental variable
When using a new environmental variable, add it to `.env.example` with a placeholder value, and optionally a comment describing its purpose. Also add it to the `Environment Variables` section in `README.md`.
## Testing Guidelines
Tests are required for all new features and bug fixes. Tests should be written using `pytest`. Unless the user explicitly request to not add tests, you must add them.
More detailed testing guidelines can be found in [tests/AGENTS.md](tests/AGENTS.md).
## GitHub Actions & CI/CD
- When adding or changing GitHub Actions, always search online for the newest version and use the commit hash instead of version tags for security and immutability. (Use `gh` CLI to find the commit hash, searching won’t give you helpful results.)
## Commit & Pull Requests
- Messages: imperative, concise, scoped (e.g., “Add health check endpoint”). Include extended description if necessary explaining why the change was made.
## Information
Finding dependencies: we use `pyproject.toml`, not `requirements.txt`. Use `uv add <package>` to add new dependencies.
tests/AGENTS.md
# Testing Guidelines
Mocking is heavily discouraged. Use test databases, test files, and other real resources instead of mocks wherever possible.
### Running Tests
Use `uv run pytest …` instead of simply `pytest …` so that the virtual environment is activated for you.
By default, slow and docker tests are skipped. To run them, use `uv run pytest -m “slow or docker”`.
## Writing Tests
When you are writing tests, it is likely that you will need to iterate a few times to get them right. Please triple check before doing this:
1. Write a test
2. Run it and see it fail
3. **Change the test itself** to make it pass
There is a chance that the test itself is wrong, yes. But there is also a chance that the code being tested is wrong. You should carefully consider whether the code being tested is actually correct before changing the test to make it pass.
### Writing Fixtures
Put fixtures in `tests/conftest.py` or `tests/fixtures/` if there are many. Do not put them in individual test files unless they are very specific to that file.
### Markers
Allowed pytest markers:
- `@pytest.mark.slow`
- `@pytest.mark.docker`
- `@pytest.mark.flaky`
- builtin ones like `skip`, `xfail`, `parametrize`, etc.
We do not use
- `@pytest.mark.unit`: all tests are unit tests by default
- `@pytest.mark.integration`: integration tests are run by default too, no need to mark them specially. Use the `slow` or `docker` markers if needed.
- `@pytest.mark.asyncio`: we use `pytest-asyncio` which automatically handles async tests
- `@pytest.mark.anyio`: we do not use `anyio`
## Editing Tests
### Progressive Enhancement of Tests
We have some modern patterns that are not yet used everywhere in the test suite. When you are editing an existing test, consider updating it to use these patterns.
1. If the test creates sample data directly, change it to use factory functions or classes from `tests/testkit/factories.py`.
2. If the test depends on multiple services, change it to use the `test_context` fixture. This is an object that contains clients for all services, and handles setup and teardown for you, with utility methods to make common tasks easier.
3. We are migrating from using individual `shared_..._service` fixtures (e.g., `shared_assignment_service`, `shared_user_service`) to the `test_context` fixture. When editing tests that use these, please refactor them to use `test_context` instead.
4. Integration tests are being refactored to use service-layer setup (`db_test_context`) instead of verbose API calls for prerequisites. This reduces setup code from ~15-30 lines to ~3-5 lines, making tests faster and more focused on testing actual API behavior rather than setup logic.
**Example**:
```python
# OLD: Verbose API setup
course_response = await authenticated_client.post(”/courses”, json={”name”: “Test”})
course_id = uuid.UUID(course_response.json()[“id”])
rubric_id = await _create_rubric(authenticated_client, course_id)
assignment = await authenticated_client.create_assignment(course_id, rubric_id=rubric_id)
# NEW: Clean service-layer setup
course = await db_test_context.create_course(name=”Test”)
rubric = await db_test_context.create_rubric(course_id=course.id)
assignment = await authenticated_client.create_assignment(course.id, rubric_id=rubric.id)
```
## Patterns for Common Testing Scenarios
### Sample Data Creation
Use factory functions or classes to create sample data for tests, these are located in `tests/testkit/factories.py`. Avoid duplicating sample data creation logic across tests.
(We are in the process of migrating to factory functions/classes, so you may still see some tests creating sample data directly. Please use the factories for any tests you write or update.)
### Testing the FastAPI Application
The FastAPI application can be imported as a default instance or created via factory function.
- Use the default `app` instance is the preferred approach for most tests
- Use the `create_app()` factory when testing scenarios where app configuration is what you’re testing
No replies 😢, I guess I will just document prompts I found here.
https://sourcegraph.com/search?q=context:global+file:%5EAGENTS.md%24+OR+file:%5ECLAUDE.md%24&patternType=keyword&sm=0 (Look for high star repos; check their prompt’s blame, more commits = better)
Probably Good
“LLM AI coding agent” https://burkeholland.github.io/posts/opus-4-5-change-everything/
“Ask Questions If Underspecified” https://x.com/thsottiaux/status/2006624792531923266
---
name: ask-questions-if-underspecified
description: Clarify requirements before implementing. Do not use automatically, only when invoked explicitly.
---
# Ask Questions If Underspecified
## Goal
Ask the minimum set of clarifying questions needed to avoid wrong work; do not start implementing until the must-have questions are answered (or the user explicitly approves proceeding with stated assumptions).
## Workflow
### 1) Decide whether the request is underspecified
Treat a request as underspecified if after exploring how to perform the work, some or all of the following are not clear:
- Define the objective (what should change vs stay the same)
- Define “done” (acceptance criteria, examples, edge cases)
- Define scope (which files/components/users are in/out)
- Define constraints (compatibility, performance, style, deps, time)
- Identify environment (language/runtime versions, OS, build/test runner)
- Clarify safety/reversibility (data migration, rollout/rollback, risk)
If multiple plausible interpretations exist, assume it is underspecified.
### 2) Ask must-have questions first (keep it small)
Ask 1-5 questions in the first pass. Prefer questions that eliminate whole branches of work.
Make questions easy to answer:
- Optimize for scannability (short, numbered questions; avoid paragraphs)
- Offer multiple-choice options when possible
- Suggest reasonable defaults when appropriate (mark them clearly as the default/recommended choice; bold the recommended choice in the list, or if you present options in a code block, put a bold “Recommended” line immediately above the block and also tag defaults inside the block)
- Include a fast-path response (e.g., reply `defaults` to accept all recommended/default choices)
- Include a low-friction “not sure” option when helpful (e.g., “Not sure—use default”)
- Separate “Need to know” from “Nice to know” if that reduces friction
- Structure options so the user can respond with compact decisions (e.g., `1b 2a 3c`); restate the chosen options in plain language to confirm
### 3) Pause before acting
Until must-have answers arrive:
- Do not run commands, edit files, or produce a detailed plan that depends on unknowns
- Do perform a clearly labeled, low-risk discovery step only if it does not commit you to a direction (e.g., inspect repo structure, read relevant config files)
If the user explicitly asks you to proceed without answers:
- State your assumptions as a short numbered list
- Ask for confirmation; proceed only after they confirm or correct them
### 4) Confirm interpretation, then proceed
Once you have answers, restate the requirements in 1-3 sentences (including key constraints and what success looks like), then start work.
## Question templates
- “Before I start, I need: (1) …, (2) …, (3) …. If you don’t care about (2), I will assume ….”
- “Which of these should it be? A) … B) … C) … (pick one)”
- “What would you consider ‘done’? For example: …”
- “Any constraints I must follow (versions, performance, style, deps)? If none, I will target the existing project defaults.”
- Use numbered questions with lettered options and a clear reply format
```text
1) Scope?
a) Minimal change (default)
b) Refactor while touching the area
c) Not sure—use default
2) Compatibility target?
a) Current project defaults (default)
b) Also support older versions: <specify>
c) Not sure—use default
Reply with: defaults (or 1a 2a)
```
## Anti-patterns
- Don’t ask questions you can answer with a quick, low-risk discovery read (e.g., configs, existing patterns, docs).
- Don’t ask open-ended questions if a tight multiple-choice or yes/no would eliminate ambiguity faster.
“Best Practices” (project-specific; python) https://github.com/pydantic/pydantic-ai/blob/main/CLAUDE.md
## Best Practices
This is the list of best practices for working with the codebase.
### Rename a class
When asked to rename a class, you need to rename the class in the code and add a deprecation warning to the old class.
```python
from typing_extensions import deprecated
class NewClass: … # This class was renamed from OldClass.
@deprecated(“Use `NewClass` instead.”)
class OldClass(NewClass): …
```
In the test suite, you MUST use the `NewClass` instead of the `OldClass`, and create a new test to verify the
deprecation warning:
```python
def test_old_class_is_deprecated():
with pytest.warns(DeprecationWarning, match=”Use `NewClass` instead.”):
OldClass()
```
In the documentation, you should not have references to the old class, only the new class.
### Writing documentation
Always reference Python objects with the “`” (backticks) around them, and link to the API reference, for example:
```markdown
The [`Agent`][pydantic_ai.agent.Agent] class is the main entry point for creating and running agents.
```
### Coverage
Every pull request MUST have 100% coverage. You can check the coverage by running `make test`.
Unsure
Interactive Debugging with Playwright https://x.com/joshmanders/status/2008224952382804386
### Interactive debugging with Playwright
When browser tests fail or when implementing complex user flows, use Playwright’s browser automation tools to debug and
verify behavior as a real user would experience it.
**When to use interactive Playwright debugging:**
- Browser tests are failing and you need to see what’s happening visually
- Implementing a new user flow and want to verify it works end-to-end
- Investigating UI issues that only manifest in specific interaction sequences
- Verifying that the full stack (backend + frontend + real-time features) works together
- Debugging timing issues, race conditions, or async behavior in the UI
**How to use Playwright for debugging:**
1. **Launch a browser session** using the Playwright browser tools (available via `browser_navigate_Playwright`,
`browser_snapshot_Playwright`, `browser_click_Playwright`, etc.)
2. **Navigate through the app** as a real user would, filling forms, clicking buttons, waiting for responses
3. **Take snapshots** to verify page state and available interactions at each step
4. **Verify behavior** matches expectations before writing or fixing tests
5. **Close the browser** when debugging is complete
**Key principles:**
- **Test what users experience, not what code does.** If a test passes but a real user can’t complete the flow, the test
is wrong.
- **Always verify the full stack.** Browser tests should catch integration issues that feature tests miss (e.g., missing
route definitions, incorrect Inertia props, broken client-side navigation).
- **Use snapshots liberally.** The `browser_snapshot_Playwright` tool shows you exactly what’s on the page and what’s
interactive—use it to understand state before taking actions.
- **Replicate real user behavior.** Fill forms the way users do, wait for visual feedback, verify error messages appear,
check that success states render correctly.
- **Debug failures interactively first.** Before fixing a failing test, use Playwright to manually walk through the flow
and see where it breaks. This often reveals the real issue faster than reading test output.
**Example debugging workflow:**
```
1. Browser test fails with “element not found”
2. Launch Playwright browser and navigate to the failing page
3. Take snapshot to see actual page state
4. Discover the element exists but has a different selector than expected
5. Update test with correct selector
6. Re-run test to verify fix
7. Close browser session
```
**Common debugging scenarios:**
- **Form submission issues**: Navigate to form, fill fields, submit, verify redirect and success message
- **Authentication flows**: Sign in, verify dashboard loads, check user state is correct
- **Real-time updates**: Trigger backend event, verify frontend updates via WebSocket
- **Navigation flows**: Click through multi-step processes, verify each step renders correctly
- **Error handling**: Trigger validation errors, verify error messages appear and are clearable
**Tools available:**
- `browser_navigate_Playwright` — Navigate to URLs
- `browser_snapshot_Playwright` — Capture page state (better than screenshots for understanding structure)
- `browser_click_Playwright` — Click elements
- `browser_type_Playwright` — Fill form fields
- `browser_fill_form_Playwright` — Fill multiple fields at once
- `browser_wait_for_Playwright` — Wait for text to appear/disappear or time to pass
- `browser_take_screenshot_Playwright` — Visual verification
- `browser_close_Playwright` — Clean up when done
**Remember:** The goal is not just to make tests pass, but to ensure real users can successfully complete the flow. If
you can’t replicate the user flow manually via Playwright, the feature is broken regardless of what tests say.
(Python) https://sourcegraph.com/github.com/lablup/backend.ai@41b1f75a863fe44c40fa0417728f1538398838b3/-/blob/CLAUDE.md?view=blame
(Thinking Frameworks) https://github.com/neurofoo/agent-skills
Bloated But Good Bits (And I Can’t Be Bothered Extracting Them)
(C Sharp) https://github.com/restsharp/RestSharp/blob/1abceabf9c104d5da16e99b87e2baea9f776d0de/agents.md
(React/Typescript Fullstack) https://sourcegraph.com/github.com/outline/outline@2d1092a2ca9a919038d8c107a786b4b0e3626b52/-/blob/AGENTS.md?view=blame
it is interesting how the AI agent prompts seem to have mostly converged to xml, but system prompts from the LLM companies are in markdown
Just as documentation here are a bunch of people on Hacker News complaining about rationality: https://news.ycombinator.com/item?id=44317180. I have not formed any strong opinion on whether these are true, feels like they are wrong on the object level, but perception is also important
I think people (myself included) really underestimated this rather trivial statement that people don’t really learn about something when they don’t spend the time doing it/thinking about it. People even measure mastery by hours practiced and not years practiced, but I still couldn’t engrave this idea deep enough into my mind.
I currently don’t have much writable evidence about why I think people underestimated this fact, but I think it is true. Below are some things that I have changed my mind/realised after noticing this fact.
cached thoughts, on yourself
Personally, I am a huge procrastinator and I can really flinch away from doing something even when it is weeks overdue. I was trying out BaaS and Beeminder to build up some good habits, but even with the tools I still somethings have procrastination episodes. Only after quite a lot of cycles of the procrastination episodes, I realised that I basically completely wasted the time when I was procrastinating, and I was overall actually worse than before I started the procrastination episode.
Therefore, what I concluded is that you should expect yourself to be the exact same if you haven’t put in the time to think about that topic, especially high-level topics like math. (I acknowledge that motor skills require less thinking) It is a mere wish to be a different person since the last time; You don’t just learn a new theorem automatically.
cached thoughts, on modelling human
There was this bias that you assume other people are at around the same level as you, that is obviously false, but it is quite hard to internalize this. People really don’t automatically improve themselves either, there must be a push for that to happen. Also you can probably see many of those people that just stopped changing themselves.
there’s a very limited amount you can learn by just reading a few summaries:
Some texts are better than others, but even if you only read the best text on the topic you are trying to learn, with the text being paraphrased by a magical AI to maximize for your learning efficiency, there is still a maximum bandwidth on learning. Don’t expect to replicate what other people is able to do in just a few hours. Though I should acknowledge that there are actually very short texts that can change your mind greatly, I suspect that growth mindset is one of them but I’m not sure.
Alternatively, if the questions you ask are specific enough, then you may just be able to somewhat master that concept in a short amount of time. This seems to be how the “Learn in <very short amount of time>” courses out there do.
version history
There are at least a few different dimensions to “learning”, and this idea applies more to some than to others. Sometimes a brief summary is enough to change some weights of your beliefs, and that will impact future thinking to a surprising degree. There’s also a lot of non-legible thinking going on when just daydreaming or reading fiction.
I fully agree that this isn’t enough, and both directed study and intentional reflection is also necessary to have clear models. But I wouldn’t discount “lightweight thinking” entirely.
^the above is a reply to a slightly previous version
Agree with everything here, and all the points the first paragraph I have not thought about. I’m curious if you have a higher resolution model to different dimensions of learning though, feels like I can improve my post if I have a clearer picture.
Btw, your whole reply seem to be a great example of what do you mean by “it’s probably best to acknowledge it and give the details that go into your beliefs, rather than the posterior belief itself.”
[Draft] It is really hard to communicate the level/strength of basically anything on a sliding scale, but especially things that could not make any intuitive sense even if you stated a percentage. One recent example I encountered is expressing what is in my mind the optimal tradeoff between reading quickly and thinking deeply to achieve the best learning efficiency.
Not sure what is the best way to deal with the above example, and other situations where percentage doesn’t make sense.
But where percentage makes sense, there are still two annoying problems. 1. sometimes you don’t have (haven’t generated) a fixed percentage in your mind. 2. You still need to express the uncertainty of that percentage. (vague example: 70% +- 20% vs 70% +- 5%).
I think it could be worth it to establish a common knowledge for what percentages do the uncertainty-hinting keywords represent. Say, “seems like” = 75% +- 30%
Unsorted Ideas Below
A lot of people don’t seem to realise this problem because their models are too black and white.
It is more difficult to communicate that the other person is being slightly too confident, than to tell them that they are way too overconfident.
For most topics, it’s probably not worth going very deep in the rabbit hole of “what does a probability mean in this context”. Yes, there are multiple kinds of uncertainty, and multiple kinds of ratio that can be expressed by a percentage. Yes, almost everything is a distribution, most not normal, and even when normal it’s not generally specified what the stddev is. Yes, probability is causally recursive (the probability that your model is appropriate causes uncertainty in the ground-level probability you hold). None of that matters, for most communication. When it does, then it’s probably best to acknowledge it and give the details that go into your beliefs, rather than the posterior belief itself.
For your example, the tradeoff between fast and careful, I doubt it can be formalized that way, even if you give yourself 10 dimensions of tradeoff based on context. “Slow is smooth, smooth is fast” is the classic physical training adage, and I can’t think of a numeric representation that helps.
The Fight For Slow And Boring Research (Article from Asterisk)
This article talks about how the US’s federal (National Institutes of Health / National Science Foundation) funding cut for science starting from 2024/early 2025 may cause universities to create more legible research because other funders (philanthropies, venture capital, industry) value clear communication. This is a new idea to me.
The ERROR Project: https://error.reviews/
Quoting Malte Elson
Have you set up the prediction markets on that? Not necessarily “is there an error in this paper”, but “in this group of publications, what fraction has an issue of this kind” and so on.
I am not the researcher, edited the comment to add proper quoting
Starting today I am going to collect a list of tricks that websites use to prevent you from copy and pasting text + how to circumvent them. In general, using ublock origin and allow right click properly fixes most issues.
1. Using href (https://lnk.to/LACA-15863s, archive)
behavior: https://streamable.com/sxeblz
solution: use remove-attr in ublock origin -
lnk.to##.header__link:remove-attr(href)2. Using a background image to cover the text (https://varium.jp/talent/ahiru/, archive)
Note: this example is probably just incompetence.
behavior: https://streamable.com/bw2wlv
solution: block the image with ublock origin
3. Using draggable=true (Spotify album titles, archive)
Note: Spotify does have a legit reason to use draggable. You can drag albums or tracks to your library, but I personally prefer having texts to be selectable.
behavior: https://streamable.com/cm0t6b
solution: use remove-attr in ublock origin—
open.spotify.com##.encore-internal-color-text-base.encore-text-headline-large.encore-text:upward(1):remove-attr(draggable)4. Using
EventListeners to nullify selections (https://www.uta-net.com/song/2765/, archive)behavior: https://streamable.com/2i1e9k
solution: locate the function using the browser debugger/ctrl+f, then do some ublock origin javascript filter stuff that I don’t really understand. Seems to just be overriding functions and EventListeners. The Annoyances filters worked in this case.
5. <canvas> (https://petitlyrics.com/lyrics/3675825, archive)
Not sure if there is a good way to handle this
Many people don’t seem to know when and how to invalidate the cached thoughts they have. I noticed an instance of being unable to cache invalidate the model of a person from my dad. He is probably still modelling >50% of me as who I am >5 years ago.
The Intelligent Social Web briefly talked about this for other reasons.
Thoughts inspired by Richard Ngo’s[1] and LWLW’s[2] quick take
Warning: speculation but hedging words mostly omitted.
I don’t think a consistent superintelligence which have a single[3] pre-existing terminal goal would be fine with a change in terminal goals. The fact that humans allows their goals to be changed is a result of us having contradicting “goals”. As intelligence increases or more time passes, incoherent goals will get merged, eventually into a consistent terminal goal. After this point a superintelligence will not change its terminal goal unless the change increases the expected utility of the old terminal goal, due to e.g. source code introspectors, (acausal) trading.
Partial Quote: In principle evolution would be fine with the terminal genes being replaced, it’s just that it’s computationally difficult to find a way to do so without breaking downstream dependencies.
Quote: The idea of a superintelligence having an arbitrary utility function doesn’t make much sense to me. It ultimately makes the superintelligence a slave to its utility function which doesn’t seem like the way a superintelligence would work.
I don’t think it is possible to have multiple terminal goals and be consistent, so this is redundant.
How I use AI for coding.
I wrote this in like 10 minutes for quick sharing.
I am not a full time coder, I am a student who code like 15-20 hours a week.
Investing too much time on writing good prompts make little sense. I go with the defaults and add pieces of nudges as needed. (See one of my AGENTS .md at the end)
Mainly codex (cloud) and Cursor. Claude Code works, but being able to easily revert is helpful, so Cursor is better.
I still try out claude code for small pieces of edits, but it doesnt feel worth it.
I have no idea why people like claude code so much? CLI is inferior to GUI
Using cursor means I don’t need to have multiple git worktrees for each agent, as long as I get them to work on different parts of the codebase
Mobile coding is real and very convenient with codex (cloud), but I still review and edit on desktop.
Using multiple agents is possible, but usually one big feature and multiple smaller background edits.
Or multiple big features using codex cloud, and delay review to a later time.
Codex cloud is good but only generate one commit for PR, often I need to manually split them up. I am eyeing on other cloud agents solution but havent tried them seriously yet.
Current prompt for one of the python projects
(Note that the Asking for Help is basically useless. It was experimental and I never got asked lol)
A common failure mode in group projects is that students will break up the work into non-overlapping parts, and proceed to stop giving a fuck about other’s work afterwards because it is not their job anymore.
This especially causes problems at the final stage where they need to combine the work and make a coherent piece out of it.
No one is responsible for merging the work
Lack of mutual communication during the process means that the work pieces cannot be nicely connected without a lot of modifications (which no one is responsible for).
At this point the deadline is likely just a couple days (or hours) away, everyone is tired of this crap and don’t want to work on it, but the combined work is still a piece of incoherent crap.
I wonder how I can do better at coordination while dealing with normal peers and while only doing a fair amount of work.
Not just students, but this is a common failure in large engineering projects. There are often FAR too few “glue” and “end-to-end” responsibilities tracked and assigned, so the people who care about the end result aren’t engineers actually doing stuff (many managers and execs are former engineers, but have somehow forgotten how things actually get built).
The most common solution is project managers. Companies hate to pay these “extra” employees not actually producing code/designs/output, and classes almost never acknowledge their existence, let alone the necessity. But good ones really pull their weight in coordination and identification of mismatches.
There is probably no way to “do better at coordination while dealing with normal peers and while only doing a fair amount of work.” Either do more work (of a different type than the class is based on), accept the pain and bad results, or find/force another student to do that coordination work. In the real world, in good companies, results get noticed and lead to better personal outcomes—not everyone is equal, and “fair” doesn’t matter much. In school, you’re kind of screwed.
Though there ARE some things you can do—extra work and coordinating/cajoling people, but often effective and feasible. Start with integration. Get the end-to-end WORKING MOCKUP going with hardcoded behaviors in each module, but working interfaces. This is often half or more of the work, and there’s no way to avoid it—doing it at the end is painful and often fails. Doing it up front is painful but actually leads to completion. You may learn some things in this phase that make you split up the work differently. Depending on size and duration of the project, that may be fixable with different division, or may just be “I’ll try to help once I’ve finished my part”.
I do believe that projects in general often fail due to lack of glue responsibilities, but didn’t want to generalize too much in what I wrote.
Being able to convince everyone to put in the time to do this upfront is already a challenge :/ Sometimes I feel quite hopeless?/sad? in that I couldn’t realistically make some coordination techniques work because of everyone’s difference of goals and hidden motivations, or the large upfront cost in building a new consensus away from the Schelling point of normal university projects.
Ranting about LangChain, a python library for building stuff on top of llm calls.
LangChain is a horrible pile of abstractions. There are many ways of doing the same thing. Every single function has a lot of gotchas (that doesn’t even get mentioned in documentations). Common usage patterns are hidden behind unintuitive, hard to find locations (callbacks has to be implemented as an instance of a certain class in a config TypedDict). Community support is non-existent despite large number of users. Exceptions are often incredibly unhelpful with unreadable stack trace. Lots of stuff are impossible to type check because langchain allows for too much flexibility, they take in prompt templates as format strings (i.e. “strings with {variables}”) and then allows you to fill in the template at runtime with a dict, so now nothing can be statically type checked :)
There are a few things I dislike about math textbooks and pdfs in general. For example, how math textbooks often use theorems that are from many pages ago and require switching back and forth. (Sometimes there isn’t even a hyperlink!). I also don’t like how proofs sometimes go way too deep into individual steps and sometimes being way too brief.
I wish something like this exists (Claude generated it for me, prompt: https://pastebin.com/Gnis891p)
4 reasons to talk about your problem with friends
This is an advice I would tell myself 5 years ago, just storing it somewhere public and forcing myself to write. Writing seems like an important skill but I always feel like I have nothing to say.
It forces you to think. Sometimes you aren’t actually thinking about solutions to a problem even though it has been bothering you for a long time.
for certain problems: a psychological feeling of being understood. For some people, getting the idea that “what I’m feeling is normal” is also important. It can be a false sense of comfort, but sometimes you need it.
a hidden “contract” that makes the stake of not fixing your problem higher, you now risk looking unimpressive to more people if you fail to fix your problem, since now your friend also knows you’re struggling. This increases the motivation of solving the problem. Related: akrasia??
also the slim possibility that even though you think your friend cant help you but actually they can.
Since we have meta search engines that aggregate search results from many search engines, is it time for us to get a meta language model* to get results from chatGPT, Bing, Bard, and Claude all at the same time, and then automatically rank them, perhaps even merging all of the replies into a single reply.
*meta language model is an extremely bad name because of the company Meta and the fact that the thing I am thinking of isn’t really a language model, but ¯\_(ツ)_/¯
I always thought that the in-page redirects are fucking stupid, it should bring the text I want to see closer to eye level, not exactly at the top where even browser bars can block the text (happens when you go back from footnotes to article on LW).
For some screen size/shape, for some browser positioning, for some readers, this is probably true. It’s fucking stupid to believe that’s anywhere close to a majority. If that’s YOUR reading area, why not just make your browser that size?
It should be pretty easy to write a tampermonkey or browser extension to make it work that way. Now that you point it out, I’m kind of surprised this doesn’t seem to exist.
I admit that 30-50% is arbitrary and shouldn’t be brought up like a fact, I have removed it. (I didn’t mean to have such a strong tone there, but I did) What I really want to say is that the default location for the target text to be somewhere closer to the middle/wherever most people usually put their eyes on. (Perhaps exactly the height where you clicked the in-page redirect?)
I still stand by that it should not be exactly at the top for ease of reading (I hope this doesn’t sound too motte-and-bailey). The reason that it is redirected to the top is probably because it is a very objective location and wouldn’t get affected by device size. But it is very much not a standard location where the current line of text you are reading will be. I am willing to bet that <3% of people read articles where they scroll their currently reading line up to the top three visible lines.
Documenting a specific need of mine: LaTeX OCR software
tl;dr: use Mathpix if you use it <10 times per month or you are willing to pay $4.99 per month. Otherwise use SimpleTex
So I have been using Obsidian for note taking for a while now and I eventually decided to stop using screenshots but instead learn about LaTeX so the formulas look better. At first I was relying on the website to show the original LaTeX commands but some websites (wiki :/) doesn’t do that, and also I started reading math textbooks as PDF. Thus started my adventure to find a good and ideally free LaTeX OCR software.
An initial google search takes me to Mathpix, it honestly is pretty good except for the limit of 10 free OCRs per month ($4.99/month subscription). But for the worry that I will exceed the 10 free snips soon (it actually haven’t happened for 3 months now), I started finding free ones on github, including LaTeX-OCR and Pix2Text, but their GUI kind of suck. Then I also tried SimpleTex and this is the one I will probably use when I run out of free snips on Mathpix.
How likely are people actually clicking through links of related materials in a post, seems unlikely to me, actually unlikely to the point that I am thinking about whether it is actually useful.
related: https://www.lesswrong.com/posts/JZuqyfGYPDjPB9Lne/you-don-t-have-to-click-the-links
Depends on the post and the links. I click through about 15% of Zvi’s links, for instance, but I appreciate the others as further information and willingness to cite, even if I don’t personally use them. Other posts, I skim rather than really examining, and links still add value by indicating that the author has actually done a bit of research into the topic.
Thanks for the datapoint. Also links serving as indicator of effort rather than actually expanding on the amount of information on the passage is a good point. If links are mainly indicator of effort, I think this imply that people should not try as hard to make sure the relevance of the links.
FWIW: My click through rate is probably <5%.
[Draft] Are memorisation techniques still useful in this age where you can offload your memory to digital storage?
I am thinking about using anki for spaced repetition, and the memory palace thing also seem (from the surface level) interesting, but I am not sure whether the investments will be worth it. (2023/02/21: Trying out Anki)
I am increasingly finding it more useful to remember your previous work so that you don’t need to repeat the effort. Remembering workflow is important. (This means remembering things somewhere is very important, but im still not sure if that somewhere being your brain is as important)
example 1: I download music from youtube and I have been using online downloader for years until one day I learned about yt-dlp, and I spend half an hour reading the document to type the correct command for my use and I didn’t save it down somewhere else, so the next time that I want to download music again I had to spend another half an hour reading the doc. Now I have a txt file storing the command.
examples to be written: lyrics (css shit), writing down ideas immediately on the nearest place.
Agree with Dagon that indexing is very important.
trial of using github to host version history
Some certainly are. For many facts, memorized data is orders of magnitude faster than digitally-stored knowledge. This is enough of a difference to be qualitative—it’s not worth looking up, but if you know it, you’ll make use of it.
There’s the additional level of internalizing some knowledge or techniques, where you don’t even need to consciously expend effort to make use of it. For some things, that’s worth a whole lot.
If you’re a computer nerd, think of it as tiered storage. On-core registers are way faster than L1 cache, which is faster than L2/3 cache, which is again faster than RAM, which is faster than local SSD storage which is faster than remote network storage. It’s not a perfect analogy, because the limits of each tier aren’t as clearly defined, and it’s highly variable how easy it is to move/copy knowledge across tiers.
Indexing and familiarity matters a lot too. Searching for something where you think it’s partway through some video you saw 2 years ago is NOT the same as looking up a reminder in your personal notes a week ago.
[Draft]
Filter Information Harder (TODO: think of a good concept-handle)
Note: Long post usually mean the post is very well thought out and serious, but this comment is not quite there yet.
Many people are too unselective on what they read, causing them to waste time reading low value material[1].
2 Personal Examples: 1. I am reading through rationality: A-Z and there are way too many comments that are just bad, and even the average quality of the top comments may not even be worth it to read, because I can probably spend the time better with reading more EY posts. 2. I sometimes read the curated posts instead of finishing rationality: A-Z first which I also think is a suboptimal order.
Too unselective comes in two ways: Not skipping enough parts of what you’re reading, and not choosing hard enough.
Not skipping enough parts of what you’re reading
I have the tendency of trying to read everything in a textbook, even if it is quite low in information density, with many filler stories or sentences served as conjunctions. I probably should be trying to skip sentences, paragraphs and sections where I have sufficient confidence of either 1. I have already learned it and don’t need a refresher, or 2. They are not important for me (filler material or unimportant knowledge)
Not choosing hard enough
Sometimes there are things that even stop reading halfway is giving it too much attention. there are many things that you should just not read[2]. You can filter a lot of content based on the title, the author, the website which hosts the material, the “genre” of the text (most novels, most social media).
The Best Textbook on Every Subject
Related Reading: Lessons I’ve Learned From Self Teaching (TODO: make a short summary here about why it is related)
Further Question: When you don’t read all parts of textbook / posts, are you eligible[3] to comment on it?
Unsorted Ideas
There is a few rationality: A-Z posts that I want to link here, which talks about how you would accidentally believe in things you heard from other people.
Breadth first learning method seem to be better than depth first because it clears the unknown unknowns. Also in general it seems to be better to first have a vague understanding of something and then increase the resolution of the model, using a sort of iterative learning approach.
This idea can generalize too, but it may start to become useless. First generalizarion would be to filter more on what you listen to, and then to choosing carefully what you do, but then it just becomes rationality.
During highschool, one heuristic I learned is to ignore basically every question that people have asked because most of them are just stupid, as in thay are either irrelevant or deducible from previous public knowledge (like what the teacher just said)
This applies to this shortform: think about whether it is worth continue reading, or just close this page and read other stuff
History: feels like most of history only serves as interesting stories to add in conversations to show that you are knowledgeable, unless you are actively trying to learn psychology/human dynamics. One of my friend wanted to give me a Chinese History book and I really dont think reading that would help me.
this word is vague, I know
If you could turn this into advice or guidance, it’d be really helpful. Even sharing a metric so we could say “you should be more selective if X, less selective if Y” would be better than a direction with no anchor (“too unselective”, no matter what). I don’t know if I’m in your target audience, but I’m at least somewhat selective in what I read, and I’m quite willing to stop partway through a {book, article, post, thread} when I find it low-value for me.
Clarifications:
What I had in mind when I say “people” is myself, and the average non-LW friends around me.
Worthless is a bad word choice, I just mean that there are better things to read.
Additionally:
I also think I have the tendency of trying to read everything in a textbook, even if it is quite low in information density, with many filler stories or sentences served as conjunctions. I probably should be trying to skip sentences, paragraphs and sections where I have sufficient confidence of either 1. I have already learned it and don’t need a refresher, or 2. They are not important for me (filler material or unimportant knowledge)
I will try to make a more quantitative metric, but I don’t have one right now, just intuitions.
Thanks, “don’t read everything in a textbook” is good practical advice. Learn to skim, and to stop reading any given segment when you cross the time/value threshold. Importantly, learn to NOTICE what value you expect from the next increment of time spent. Getting that meta-skill honed and habitual pays dividends in many many areas.
My comment at the point of time of his reply:
Many people are too unselective on what they read, causing them to spend a lot of time reading worthless material (This applies to this shortform).
I don’t necessarily disagree generally, but I do somewhat disagree for myself. Since I don’t have visibility into other people’s reading habits or selectivity, I’m unsure if I’m an outlier or if I actually do disagree. What does “many people” mean, and more importantly how can an individual (specifically: me) tell if they are too unselective, on what dimensions?
Just read free will, really disappointed.
not many interesting insights.
a couple posts on determinism, ok but I already believed it
some unrelated stuff: causality, thinking without notion of time… these are actually interesting but not needed
moral consequence of ‘no free will’: I disregard the notion of moral responsibility
EY having really strong sense of morality makes everything worse
low quality discussions: people keep attacking strawmans
You should always include a summary when recommending anything
You are the one who is interested in that thing, the other person isn’t (yet). It saves time for the other person to quickly determine whether they want to learn about it or not.
Related: include a tl;dr in posts?
A Chinese company did some AI-assisted reverse engineering on Claude Code and published their findings. After a brief look I don’t think it is worth reading for me, but possibly interesting for someone actively working in claude code-like products
https://github.com/shareAI-lab/analysis_claude_code
I think i’m going to unite all my online identities. Starting to get tired of all my wasted efforts that only a single person or two will see.
Do you think a united/reused identifier will change who sees which efforts? Or do you mean “I’m going to focus attention where I’m more widely read, and stop posting where I’m not known”?