Down Only

Describe who you are and what you're into.

[Down Only @DownOnlyLLC]

Insightful

[goodalexander @goodalexander]

So basically a bunch of giga autists at a Chinese quant fund are going to cause the Nasdaq to crash but nobody has realized that yet

None of this even phases me anymore

[Stefan @creativestefan]

Surfed the internet for cool UI inspos and resources, Here's what i found:

- 60fps (motion) https://t.co/LoFhWprvAY
- Divs (Webflow component) https://t.co/nNqo5bbUi8
- Efecto (CSS effects) https://t.co/A4nZZzmj24
- Raydain (design and code) https://t.co/JIxM1EeRfS
- Visitors (Web Traffic) https://t.co/PMV9If3igx

[Naval @naval]

The secret to investing is to invest in unstoppable people building inevitable things.

[Meng To @MengTo]

I recorded a 50-min tutorial on prompting top-tier landing pages with Gemini 3

[demisdev @demisdev]

Great tips on creating a good CLAUDE .md

https://t.co/ooA3PsvmP8

[Alex Lieberman @businessbarista]

I’m non-technical but want to deeply understand AI.

@karpathy's “Intro to LLMs” is the best resource I’ve found so far.

Here are my biggest takeaways and questions from his 60-minute talk:

1. A large language model is “just two files.”

Under the hood, an LLM like LLaMA‑2‑70B is literally (1) a giant parameters file (the learned weights) and (2) a small run file (code that implements the neural net and feeds data through it).

Question: If the architecture code is tiny and public, what actual moat is left besides the weights?

2. Open‑weights vs closed models.

LLaMA‑2 is open‑weights: architecture + weights + paper are public. GPT‑4, Claude, etc. are closed: you get an API/web UI but not the actual model.

Question: For a company, when is “renting” a closed model strategically worse than owning an open‑weights model?

3. Training vs inference: training is the hard, expensive part.

Running the model (inference) is cheap; getting the weights (training) is a major industrial process.

Question: Where is the greatest axis of innovation in front of us to lower the cost of training significantly?

4. Pre‑training compresses ~10 TB of internet text.

LLaMA‑2‑70B is trained on roughly 10 TB of scraped internet text, compressed into 140 GB of parameters—a ~100× lossy compression of “internet knowledge.”

Question: Given that we’ve run out of knowledge on the internet to pre-train models on, is new data going to be the limiting factor on model improvement moving forward?

5. Training scale: ~6,000 GPUs × 12 days ≈ ~$2M for LLaMA‑2‑70B.

That’s already described as “rookie numbers” compared to modern frontier models, which are ~10× bigger in data/compute and cost tens to hundreds of millions.

Question: How far are we from “more compute” no longer being a competitive advantage?

6. Frontier models just scale this up by another ~10×.

State‑of‑the‑art models (i.e. GPT‑5) simply dial up parameters, data, and compute by large factors relative to LLaMA‑2‑70B.

Question: How much of GPT‑5‑style capability is just more scale vs genuinely new algorithms?

7. Core objective of an LLM predict the next word in a sequence.

LLMs are trained to take a sequence like “the cat sat on the” and predict the probability distribution over the next word (“mat” with ~97%, etc.).

Question: The beauty and the curse of LLMs is them being probabilistic. How can we create the right constraints such that people trust LLMs in enterprise settings?

8. Architecture is known: the Transformer.

We know all the math and wiring (layers, attention, etc.); that part is transparent and simple relative to behavior.

Question: If the architecture is commoditized, where exactly do you build sustainable differentiation? And how much more shelf life is there on the Transformer before a new architecture takes over?

9. Parameters are a black box.

Billions of weights cooperate to solve next‑word prediction, but we don’t really know “what each one does”—only how to adjust them to lower loss.

Rabbit hole: Read about mechanistic interpretability work.

10. Treat LLMs as empirical artifacts, not engineered machines.

They’re less like cars (fully understood mechanisms) and more like organisms we poke, test, benchmark, and characterize behaviorally.

Rabbit hole: Understand the current process for evals & if/what limitations exist in today’s eval tools.

11. Pre‑training vs. fine-tuning.

Pre-training favors quantity over quality; Fine-tuning flips that: maybe ~100k really good dialogs matter more than another terabyte of web junk.

Question: How much incremental performance can fine tuning and RHLF drive for models? Is it a fraction of what pre training does for performance or is it more meaningful than that?

12. Knowledge vs behavior.

Pre-training loads the model with world knowledge; Fine-tuning teaches it to be helpful, harmless, and to respond in Q&A format.

Rabbit hole: I’d love to deeply understand how exactly a model is fine tuned from beginning to end.

13. Reinforcement learning from human feedback (RLHF) via comparisons.

It’s often easier for labelers to rank several options vs. write the best one from scratch; RLHF uses these rankings to further improve the model.

Question: When exactly does it make sense to fine tune a model vs. use RHLF & does the answer depend on the domain of knowledge the model will be used for?

14. Closed vs open models.

Closed models are stronger but opaque; open‑weights models are weaker but hackable, fine‑tunable, and deployable on your own infra.

Question: As companies deploy agents, what is the most important consideration to make as they think about their AI tech stack?

15. Scaling laws: performance is a smooth, predictable function of model size and data.

Given parameters (N) and data (D), you can predict next‑token accuracy with surprising reliability, and the curve hasn’t obviously saturated yet.

Question: If capabilities keep scaling smoothly, what non‑technical bottlenecks (data rights, energy, chips, regulation) become the real limiters?

16. GPU and data “gold rush” is driven by scaling law confidence.

Since everyone believes “more compute → better model,” there’s a race to grab GPUs, data, and money.

Question: Let’s assume scaling laws no longer scale. Who is most screwed when the music stops?

17. LLMs as tool-using agents, not just text predictors.

Modern LLMs don’t just “think in text”; they orchestrate tools.

Given a natural-language task, the model decides to (1) browse the web, (2) call a calculator or write Python to compute ratios and extrapolations, (3) generate plots with matplotlib, and (4) even hand off to an image model (like DALL·E) to create visuals.

The intelligence is increasingly in the coordination layer: the LLM becomes a kind of “foreman” that plans, calls tools, checks outputs, and weaves everything back into a coherent answer.

18. How do LLMs know when to make a tool call?

“It emits special words, e.g. |BROWSER|. It captures the output that follows, sends it off to a tool, comes back with the result and continues the generation. How does the LLM know to emit these special words? Finetuning datasets teach it how and when to browse, by example.”

19. System 1 vs System 2 thinking applied to LLMs.

Concept popularized in Thinking Fast and Slow.

System 1 = fast, instinctive; System 2 = slower, deliberate, tree‑searchy reasoning.

Right now LLMs mostly operate in System 1 mode: same “chunk time” per token.

Rabbit hole: Explore how “chain‑of‑thought” method works & what limitations still exist in System 2 thinking for LLMs.

20. Desired future: trade time for accuracy.

This was before the first reasoning model (GPT O1) came out.

At the time, Karpathy talked about this idea of wanting to be able to say: “Here’s a hard problem, take 30 minutes,” and get a more accurate answer than a quick reply; currently, the models can’t do that in a principled way.

21. Model self‑improvement example: AlphaGo’s two stages.

AlphaGo first imitates human Go games, then surpasses humans via self‑play and a simple, cheap reward signal (did you win?).

Question: What’s the best way to improve models in domains where there isn’t a simple reward function, like creative writing or design?

22. Retrieval‑augmented generation (RAG) as “local browsing.”

Instead of searching the internet, the model searches your uploaded files and pulls snippets into its context before answering.

Question: Where does RAG break down in production?

23. Think of LLMs as the kernel process of a new operating system.

This process is coordinating resources including tools, memory, and I/O for problem-solving.

Future LLM will:
- read/generate text
- have more knowledge than any single human about all subjects
- browse the internet
- use existing software infrastructure
- see and generate images and video
- hear and speak and generate music
- think for a long time using system 2
- “self-improve” in domains with a reward function
- customized and fine-tuned
- communicate with other LLMs

Rabbit hole: Draw out the LLM OS and explain it to someone. This will show how well you understand the technology.

24. The LLM OS is reminiscent of today’s operating systems.

The finite context window is like working memory; browsing/RAG are like paging data in from disk or the internet; rapidly growing closed vs. open ecosystem; Managing what’s in context is a core challenge.

Rabbit hole: Explore techniques for working across many context windows & longer-running tasks.

25. New computing stack → new security problems.

Just as OS’ created new attack surfaces (malware, exploits), LLM‑centric stacks create their own families of attacks. Jailbreaks, adversarial prompting, adversarial suffixes, and prompt injection.

Question: security for AI systems seems orders of magnitude harder than traditional software because the # of edge cases feels infinite. Is this assumption right or wrong?

26: LLMs are a new computing paradigm with huge promise and serious challenges.

They compress internet‑scale knowledge, act as operating‑system‑like kernels, orchestrate tools and modalities, and open up both transformative products and novel security risks.

Question: what is the most nascent part of the LLM OS that needs to be built up in order to accelerate diffusion of the technology?

Link to the full “Intro to LLMs” video below 👇

[Ahmad @TheAhmadOsman]

> be anthropic engineer
> realize long-running agents still have goldfish memory
> every new context window = new intern who forgot everything from yesterday
> project goes from “build a clone of ChatGPT” to “why is half the frontend missing again?”

> agents try to one-shot entire apps
> run out of context mid-feature
> next session wakes up like “boss… who touched the router folder? why is the server on fire?”

> other times claude walks in
> sees 3 buttons rendered
> declares the whole project complete
> packs up its laptop
> goes home

> humans don’t work like this
> engineers leave breadcrumbs
> notes, git commits, tests, todo lists
> “here’s what I did, here’s what’s next, don’t break the login page again please”

> so anthropic builds a harness based on that
> two-agent setup: initializer agent, coding agent

> initializer agent = the senior dev on day one
> sets up:
> – _init.sh
> – claude-progress.txt
> – feature_list.json (200+ features, all marked failing)
> – the first git commit
> basically: “here’s the blueprint, don’t get cute”

> coding agent = the worker bee
> every session:
> – read the progress
> – read the git log
> – read the feature list
> – pick ONE feature
> – implement it
> – test it end-to-end as an actual user
> – commit code
> – leave notes
> – do NOT break anything, or revert yourself

> incremental progress > chaos
> and forcing the agent to act like a real engineer = night and day difference

> testing was the big “aha”
> claude kept marking features done that absolutely were not done
> (“unit tests pass” ≠ “the app works”)

> give it browser automation + puppeteer
> claude suddenly starts catching bugs it introduced 5 minutes ago
> screenshots, clicks, actual user flows
> end-to-end or bust

> limitations still there
> puppeteer can’t show alert modals
> claude can’t see everything
> vision quirks remain
> but it’s way closer to real QA than “lol curl localhost:3000”

> typical session now looks like:
> “pwd”
> read progress
> read features
> read git log
> start server
> sanity test
> fix broken stuff
> choose next feature
> implement
> test
> commit
> leave breadcrumbs
> repeat

> four classic failure modes solved with structure:
> – agent declaring victory too early → feature list
> – messy environment → git + progress logs
> – premature ‘passes’ → real testing
> – agent forgot how to run app → _init.sh

> does it solve everything? no
> still open questions:
> single agent vs multi-agent division of labor
> maybe future = dedicated QA agent, cleanup agent, test writer agent
> maybe research workflows get similar scaffolding
> maybe finance models get their own version

> but the core insight stands:
> long-running agents don’t fail because they’re dumb
> they fail because we throw them into multi-session hell
> without giving them the engineering rituals humans rely on

> give them structure, tools, tests, logs, diffs
> they stop acting like goldfish
> and start acting like teammates

[Eric Buess @EricBuess]

claude update

claude

/model -> opus

/plugin marketplace add anthropics/claude-code

/plugin install frontend-design@claude-code-plugins

shift+tab until you see plan mode

“Use the frontend-design skill to [describe what you want to build]”

🔥

@claudeai @AnthropicAI

[Hrishi @hrishioa]

Opus 4.5 (new model from @AnthropicAI) can do something no model could do until now: It can close the design loop.

This is (in my testing) the first model that can reliably do the visual loop of

Generate Code ⇛ Render ⇛ Look at it ⇛ Improve.

Step 3 (Visual critique) has been a real problem for so long. Models will be myopic or defensive when reviewing designs - it's been hard to tell if this has been a training or a vision problem.

Opus 4.5 seems to have fixed it - it's not amazing, but it finally *can* do it.

Claude models have historically (once again, in my testing) lagged behind in terms of visual understanding. Gemini for the last year has been the best - but there might be a new leader.

[Aurimas Griciūnas @Aurimas_Gr]

Building even a simple 𝗽𝗿𝗼𝗱𝘂𝗰𝘁𝗶𝗼𝗻 𝗴𝗿𝗮𝗱𝗲 𝗥𝗲𝘁𝗿𝗶𝗲𝘃𝗮𝗹 𝗔𝘂𝗴𝗺𝗲𝗻𝘁𝗲𝗱 𝗚𝗲𝗻𝗲𝗿𝗮𝘁𝗶𝗼𝗻 (𝗥𝗔𝗚) 𝗯𝗮𝘀𝗲𝗱 𝗔𝗜 𝘀𝘆𝘀𝘁𝗲𝗺 is a challenging task. Read until the end to understand why 👇

Here are some of the moving parts in the RAG based systems that you will need to take care of and continuously tune in order to achieve desired results:

𝗥𝗲𝘁𝗿𝗶𝗲𝘃𝗮𝗹:

𝘍 ) Chunking - how do you chunk the data that you will use for external context.

- Small, Large chunks.
- Sliding or tumbling window for chunking.
- Retrieve parent or linked chunks when searching or just use originally retrieved data.

𝘊 ) Choosing the embedding model to embed and query and external context to/from the latent space. Considering Contextual embeddings.

𝘋 ) Vector Database.

- Which Database to choose.
- Where to host.
- What metadata to store together with embeddings.
- Indexing strategy.

𝘌 ) Vector Search

- Choice of similarity measure.
- Choosing the query path - metadata first vs. ANN first.
- Hybrid search.

𝘎 ) Heuristics - business rules applied to your retrieval procedure.

- Time importance.
- Reranking.
- Duplicate context (diversity ranking).
- Source retrieval.
- Conditional document preprocessing.

𝗚𝗲𝗻𝗲𝗿𝗮𝘁𝗶𝗼𝗻:

𝘈 ) LLM - Choosing the right Large Language Model to power your application.

✅ It is becoming less of a headache the further we are into the LLM craze. The performance of available LLMs are converging, both open source and proprietary. The main choice nowadays is around using a proprietary model or self-hosting.

𝘉 ) Prompt Engineering - having context available for usage in your prompts does not free you from the hard work of engineering the prompts. You will still need to align the system to produce outputs that you desire and prevent jailbreak scenarios.

And let’s not forget the less popular part:

𝘏) Observing, Evaluating, Monitoring and Securing your application in production!

What other pieces of the system am I missing? Let me know in the comments 👇

#LLM #AI #MachineLearning

[Dwarkesh Patel @dwarkesh_sp]

The @karpathy interview

0:00:00 – AGI is still a decade away
0:30:33 – LLM cognitive deficits
0:40:53 – RL is terrible
0:50:26 – How do humans learn?
1:07:13 – AGI will blend into 2% GDP growth
1:18:24 – ASI
1:33:38 – Evolution of intelligence & culture
1:43:43 - Why self driving took so long
1:57:08 - Future of education

Look up Dwarkesh Podcast on YouTube, Apple Podcasts, Spotify, etc. Enjoy!

[The Sigma Mindset @thesigmamindset]

This is the best way you can Influence any human being ‼️‼️

[𖣂Prince𖣂 @OS3992]

If you’re going to do it, then do it. Don’t lie to yourself.

[Rohan Paul @rohanpaul_ai]

This is where it all started.

Here, 19-yo Stanford dropout Sam Altman giving his first-ever startup pitch.

He dropped out of Stanford to start Loopt, sold it in 2012 for $43.4 mn.

Then invested via Hydrazine and later led Y Combinator before co-founding OpenAI in 2015

[nic carter @nic_carter]

the most important thinker in AI, in my opinion, is this 23 year old. leo aschenbrenner.

he has been more right, both in a testable predictive sense and in a market sense than virtually anyone else.

and most importantly, he's not an AI doomer, he's not an e/acc, but rather a secret third thing.

[Cody Schneider @codyschneider]

if you just got into YC and your growth strategy is “product hunt” please for the love of god read this so i dont have an aneurysm

these are the playbooks working right now

for b2b

scape every target customers email from apollo builtwith google maps directories

everywhere

validate the emails something like millionverifier

cold email all of them with something like instantly ai

make a weekly podcast for your target customers, sequence these same emails into an newsletter that promotes the podcast

turn podcast into clips schedule to all social

google ads for bottom of funnel keywords with conversion event for signup

facebook ads and linkedin ads customer match list those emails

pixel everyone who touches the website across all channels

remarketing to them indefinitely

email drip nurture for 3 month to everyone who signs up

email once a week with product updates

you’re not a $1M ARR company in 12 months

for b2c

make thousands of pieces of organic content and hundreds if tiktoks instagrams and youtubes

post across them all

affiliate program for these same influencers

hire influencers for sponsored posts

do programmatic SEO for keywords related tot every keyword your custom would search online

take organic content and do facebook ads tiktok ads youtube ads with signup conversion event

pixel everyone who touches the website across all channels

remarketing to them indefinitely

email drip nurture for 3 months to everyone who signs up

email once a week with product updates

you’re now a $1M ARR company in 12 months

[elvis @omarsar0]

How do you build effective AI Agents?

This is a problem I think deeply about with other AI devs and students.

Simplicity works well here.

I think we can all learn a lot from how Claude Code works. The Claude Agent SDK Loop generalizes the approach to build all kinds of AI agents.

I wrote a few notes from Anthropic's recent guide.

The loop involves three steps:

Gathering Context: Use subagents (parallelize them for task efficiency), compact/maintain context, and leverage agentic/semantic search for retrieving relevant context for the AI agent.

Taking Action: Leverage tools, prebuilt MCP servers, bash/scripts, and generate code to take action and retrieve important feedback/context for the AI agent.

Verifying Output: You can define rules to verify outputs, enable visual feedback (this becomes increasingly important in multimodal problems), and consider LLM-as-a-Judge to verify quality based on fuzzy rules.

I believe this is a really clean and solid framework for how to build and work with AI agents in all kinds of domains.

[Elon Musk @elonmusk]

With rare exception, ideas really are trivial compared to execution.

For example, the idea of going to the Moon is simple, but ACTUALLY going to the Moon is staggeringly difficult.

[Claude @claudeai]

This morning we announced several upgrades to Claude Code.

We also launched two new features for managing context on the Claude Developer Platform.

Here’s what’s new:

[Yegor @yegormethod]

met this guy in dubai who helps people "restructure wealth internationally"

drives a $3M pagani
has 7 passports
definitely not laundering money (😉)

his system for making money untouchable:

(posting this from a VPN)

the "Dubai Stack":
- dubai company (0% tax)
- estonian holding (blockchain friendly)
- singapore trading (banking hub)
- swiss trust (privacy laws)
- cayman foundation (asset protection)

money flows like this:
revenue → dubai
dubai → estonia
estonia → singapore
singapore → switzerland
switzerland → cayman
cayman → your pocket

completely legal
completely untraceable
completely untaxable

he showed me a client:

$50M annual revenue
effective tax rate: 0.3%
saved $19M last year
government can't touch it

but here's the wild part:

he charges 10% of tax saved
makes $30M/year
from 15 clients
works 4 months annually

lives on a yacht
dates instagram models
has tea with sheikhs
probably on 6 watchlists

his quote:
"paying taxes is a choice
only poor people don't know it's optional"

got raided once
they found nothing
everything's in jurisdictions
that don't cooperate

levels to this shii