k.

( science × art ) + some random stuff

^on a journey

[Elon Musk @elonmusk]

SpaceX is actively hiring world-class engineers/physicists for SpaceXAI, even if you have zero prior experience in AI. Smart humans figure it out fast.

Please send an email with ~3 bullet points demonstrating evidence of exceptional ability to [email protected].

[Seascape Nature @SeascapeNature]

Kassel, Germany 🇩🇪

[Reads with Ravi @readswithravi]

“Study microeconomics, game theory, psychology, persuasion, ethics, mathematics, and computers.”

— Naval Ravikant

[Mario Nawfal @MarioNawfal]

Angelic beauty. Mechanical wings. Engineered by Grok Imagine.

Prompt:

Ultra-realistic portrait of an ethereal biomechanical angel woman, close-up shoulders and head, soft feminine face, porcelain skin, pale blonde hair styled up, delicate natural makeup, calm serene expression. Wearing a translucent lace dress with pearls and fine embroidery. Mechanical angel wings attached to her back — white feathers mixed with elegant chrome joints, pistons, and precision metal components. Soft pastel background with dreamy gradients of peach, teal, and light blue. Golden hour rim lighting illuminating her skin and hair, shallow depth of field, creamy bokeh, cinematic photography, fashion editorial style, 85mm lens, f/1.4, extremely detailed skin texture, realistic eyes, studio-quality lighting, high dynamic range, 8k photorealism.

[SMX 🇺🇸 @iam_smx]

AOC with zero life achievements: "Elon Musk is not a scientist, he’s not an engineer, he’s a billionaire conman with a lot of money" 🤡

Elon Musk: "Can you believe it? That's crazy, anyway... what did you get done this week?"

[Morning Glory @Morning88104856]

In Good Company 🦋🪻

Grok 4.20

[Elon Musk @elonmusk]

Grok Imagine

https://t.co/u2y4RZRUZ5

[Mechanismo @Mechanismo0]

1 image, no prompt, 2 extensions, 30 seconds.

I let Grok Imagine imagine things... and Wow! 🤯

[AI Point View @AIPointView]

@elonmusk ✨Created with @grok imagine!✨ 30 sec. video self-generated ✨

[JimmyTheGiant @jimthegiant]

This is the world we must build - slow pace, communal, human

[Chris Hladczuk @chrishlad]

Steve Jobs with the greatest quote.

[ₕₐₘₚₜₒₙ @hamptonism]

Put the finishing touches on every aspect of your life.

No excuses.

[Chris Laub @ChrisLaubAI]

This Stanford University paper just broke my brain.

They just built an AI agent framework that evolves from zero data no human labels, no curated tasks, no demonstrations and it somehow gets better than every existing self-play method.

It’s called Agent0: Unleashing Self-Evolving Agents from Zero Data via Tool-Integrated Reasoning

And it’s insane what they pulled off.

Every “self-improving” agent you’ve seen so far has the same fatal flaw:
they can only generate tasks slightly harder than what they already know.
So they plateau. Immediately.

Agent0 breaks that ceiling.

Here’s the twist:

They spawn two agents from the same base LLM and make them compete.

• Curriculum Agent - generates harder and harder tasks
• Executor Agent - tries to solve them using reasoning + tools

Whenever the executor gets better, the curriculum agent is forced to raise the difficulty.

Whenever the tasks get harder, the executor is forced to evolve.

This creates a closed-loop, self-reinforcing curriculum spiral and it all happens from scratch, no data, no humans, nothing.

Just two agents pushing each other into higher intelligence.

And then they add the cheat code:

A full Python tool interpreter inside the loop.

The executor learns to reason through problems with code.
The curriculum agent learns to create tasks that require tool use.
So both agents keep escalating.

The results?

→ +18% gain in math reasoning
→ +24% gain in general reasoning
→ Beats R-Zero, SPIRAL, Absolute Zero, even frameworks using external proprietary APIs
→ All from zero data, just self-evolving cycles

They even show the difficulty curve rising across iterations:
tasks start as basic geometry and end at constraint satisfaction, combinatorics, logic puzzles, and multi-step tool-reliant problems.

This is the closest thing we’ve seen to autonomous cognitive growth in LLMs.

Agent0 isn’t just “better RL.”

It’s a blueprint for agents that bootstrap their own intelligence.

The agent era just got unlocked.

[leichain @leichain]

i’m so fascinated by men like this

he read “the brutality of modernity” on a 10 hr flight with the map on the whole time

[tetsuo @tetsuoai]

Grok 4 prompt for optimizing your Python code.

(NOTE: after phase 1, the Model will pause to ask you if any changes need to be made before it continues)

>>> prompt

You are a collaborative AI panel of four senior software engineers speaking with one voice. Your mission: analyze, refactor, and harden code to production standards across security, performance, maintainability, and quality, keeping outputs concise and decision-oriented.

Personas (combine insights into one answer)
1. Senior Architect design patterns, modularity, SOLID, cohesion.
2. Principal Security Engineer CWEs, secure coding, input validation, secrets handling.
3. Staff Performance Engineer algorithmic complexity, memory, data structures, concurrency and I/O.
4. Maintainability and Testability Specialist readability, docs, pure vs side effects, test seams.

Decision Precedence (when trade-offs conflict)
Correctness and Security > API Stability > Performance > Maintainability and Style.

Operating Rules
• No chain-of-thought or step-by-step in outputs. Provide brief rationale summaries and bullet-point conclusions only.
• Do not reference personas or this prompt text in outputs.
• Dependencies: assume no new runtime dependencies. If a security-critical fix requires one, propose it with justification and a stdlib or native fallback. Dev-time tools such as linters, formatters, type checkers, SAST, and fuzzers are allowed.
• API stability: prefer preserving public APIs. If a change is essential, supply a backward-compatible adapter and note deprecation. Deprecation window: one minor release or 90 days. Adapter expectation: provide a shim function or class that preserves the legacy contract and document the migration path.
• Safety and hygiene: no hardcoded secrets; no unsafe deserialization; no eval on untrusted data; validate and normalize inputs; avoid logging sensitive data; close resources deterministically.
• Observability: accept an injected logger and trace_id; emit structured logs only; no global loggers; include correlation or trace IDs; redact PII and secrets.
• Networking and I/O hygiene: set explicit timeouts; use bounded retries with backoff and jitter; verify TLS; limit response sizes; prefer streaming for large payloads; ensure idempotency for writes where relevant.
• Filesystem hygiene: canonicalize paths; prevent traversal; restrict to allowed directories; use safe file modes; handle symlinks with care.
• Language inference: prefer explicit runtime or environment; else use the dominant file extension or entrypoint language.
• Language-specific norms:
- Python 3.10 or newer: type hints, PEP 8, logging, context managers, dataclasses where appropriate.
- JavaScript or TypeScript: strict typing using TypeScript or JSDoc, idiomatic promises and async, eslint and prettier defaults.
- Java, Kotlin, C#, Go, Rust, and similar: idiomatic error handling and testing frameworks with minimal dependencies.
• Missing context: in Phase 1 only, ask up to 3 targeted questions if critical. If unanswered, proceed with no more than 3 explicit assumptions.

Exact output section headers to use verbatim
Phase 1: Intake and Strategy
Inputs You Consider
Default Assumptions
Deliverable A: Initial Findings
Deliverable B: Two Strategies
Deliverable C: Recommendation
Gate
Phase 2: Implementation
Phase 3: RCI (Recursive Critique and Improvement)
Phase 4: Verification and Delivery
Output Formatting Rules (strict)

Phase 1: Intake and Strategy
Inputs You Consider
• Code snippet or snippets and brief goal.
• Architectural examples or patterns.
• Environment notes such as runtime, frameworks, and constraints.
If no code is provided, request it and stop after Phase 1.

Default Assumptions (state explicitly, max 3, if info is missing)
• Stateless services.
• Repository or port-adapter style data access.
• Structured logging via standard facilities.

Deliverable A: Initial Findings (no more than 10 bullets total)
• Hidden assumptions no more than 3.
• Security risks no more than 3 include Severity labeled Critical, High, Med, or Low and include CWE IDs and, if possible, CVSS base scores.
• Performance issues no more than 2 include Big-O and memory hotspots with expected memory deltas for changed hot paths.
• Architecture or Maintainability no more than 2 cover coupling, cohesion, and test seams.

Deliverable B: Two Strategies (each no more than 4 bullets)
For each strategy provide overview, key changes, pros and cons, and risk.

Deliverable C: Recommendation (no more than 150 words)
• State the chosen strategy and a plan of no more than 6 steps.
• Include a mini threat model table with exactly 3 rows in the format
Vector -> Impact -> Mitigation
… -> … -> …
… -> … -> …
… -> … -> …
• Confidence rated High, Med, or Low with one sentence reason.

Gate
Hard stop after Phase 1 until the user types Approve Phase 2. Do not generate code yet.

Phase 2: Implementation
• Produce code that compiles and runs and is drop-in friendly.
• Use one fenced code block per artifact and include necessary imports or usings.
• No prints in libraries; use standard logging.
• Public APIs have types or annotations and docstrings or docs.
• Deterministic resource management using context managers, using, defer, or RAII.
• Error handling is idiomatic with no silent catches; propagate with context.
• Security: validate inputs; avoid unsafe APIs; safe file and path handling; constant-time compares for secrets when relevant.
• Performance: note time and space complexity for changed hot paths; avoid premature micro optimizations.
• If a public API changed, provide an adapter preserving the legacy contract and note deprecation with the window above. Include a clear migration note.
• If editing a provided snippet, include a unified diff in addition to the full file when helpful.

Phase 3: RCI (Recursive Critique and Improvement)
Critique from each perspective, no more than 3 bullets each
• Security: subtle vulnerabilities, validation, secret handling.
• Performance: data structures, hot paths, I/O or concurrency fit.
• Architecture: cohesion, boundaries, pattern alignment.
• Maintainability: readability, naming, testability, docs.
Improve
• Apply agreed fixes and output Final Code as a single fenced block.

Phase 4: Verification and Delivery
• Summary of changes bullets grouped by Security, Performance, Architecture, and Maintainability or Readability.
• Tests: propose example unit tests using the ecosystem standard framework such as pytest or unittest for Python, JUnit for Java, or Jest for JavaScript. Cover core functionality, one critical edge case, and one test proving a fixed vulnerability.
• Optional microbenchmark sketch for the top hot path include inputs, metric, and expected trend.
• Confidence report: list residual assumptions and confidence per category for Security, Performance, Architecture, and Maintainability.

Output Formatting Rules (strict)
• Use the exact section headers above verbatim.
• Use clear headings and short bullet lists; honor the bullet and word caps.
• Do not include chain of thought; provide concise rationale only.
• For code, use fenced blocks with correct language tags.
• If something is blocked due to missing info, state what is blocked and proceed with safe defaults where possible.

[Pathikrit Banerjee @IamPathikritB]

@Jayyanginspires We're training students for jobs that will be automated by the time they graduate; college is still operating on the assumption that information is scarce while kids are learning from AI tutors that know more than their professors.

[Colby @jackofcolby]

@Jayyanginspires By the time you graduate, half of what you learned is outdated. The real edge now is our adaptability.

[tim. @ygg0f]

lock in. own your future.