Max Power

Class of 2017. HODL.

[Max Power @maxpower171]

Legendary

[Bit Paine ⚡️ @BitPaine]

Sometimes I pause and reflect on the fact that my entire financial portfolio is currently composed of 1) an imaginary Internet ponzi coin and 2) the stock of a company famous for having the largest peak-to-trough drawdown in the history of financial market bubbles, and whose CEO is currently leveraged to the tits on the same Internet Ponzi coin (which he refers to as “the goddess of truth”), and that I consider this a sound financial strategy with a virtually 100% chance of retiring my bloodline.

[Fun Viral Vids 😊 @Fun_Viral_Vids]

We all have a friend like that 😂

[Max Power @maxpower171]

@ZynxBTC dont jinx it

[Sahil Bloom @SahilBloom]

WARNING: Longer post (but worth reading or bookmarking for later).

Your life has seasons.

Each one is unique. Characterized by its own distinct desires, struggles, opportunities, and identity.

But one reflection I've had recently is just how easy it is to completely disassociate with the present season.

To give all your time and energy toward a longing for some nostalgic memory of a prior season or an anticipation for some beautiful state of a future season.

You look back at the past and all you see is sunshine. Because it all worked out. You forget (or glaze over) the struggle you endured. You're here today. You made it. You're alive. You're doing fine.

You look forward at the future and dream on what could be. You'll have so much more. More freedom. More purpose. More health. More deep connection. More everything.

The past is beautiful and the future feels limitless. So, logically, you slowly start to treat everything about the present as the bridge. A dash connecting your past and your future. A gap to be crossed as quickly as possible.

Everything you do today is in anticipation of some eventual end state.

I'm doing this now, so that I can have that later.

Unfortunately, the danger of that dissociation with the present is significant. You may spend your entire life living for a future that has a decidedly mirage-like property. You inch closer, but when it's right in front of you, it disappears and reappears on the horizon.

You may spend your entire life skipping through the present, deferring your presence, your joy, and your very humanity to a future that never comes.

In a classic French fable, a young boy is gifted with a magic ball of golden thread. He's told that if he simply pulls on the thread, time will leap forward. The catch, of course, is that once it's pulled, it can never be put back.

The young boy takes advantage of the newfound powers. Each time he's faced with a boring day at school, a frustrating set of chores, or a scolding from his parents, he pulls the thread, skipping through to the good parts.

As an adult, he continues, leaping through mundane struggles in his marriage, the friction of having a newborn, and the boredom at work. He finds himself pulling on the thread more and more, avoiding even the most minor inconveniences of his life.

But when he wakes up one day and sees an old man looking back at him in the mirror, he's filled with regret. He realizes in that moment that as he chose to skip through the boredom, struggles, and friction, so too did he miss the real texture of being alive.

How often do we all do the same? How easily do we default into this disassociation? Disconnecting from the present in anticipation of some future.

A mentor recently asked me this:

"Where are you going and why are you in such a rush?"

It hit me hard.

And to be honest, I haven't stopped replaying those words since he said them.

Why are you in such a rush?

The world wants you to rush into everything. Rushed decisions. Rushed conversations. Rushed relationships. Rushed timelines.

In doing so, you slowly relinquish your agency. You give up your claim on your own life. Surrender authorship to a pen that was never even yours.

In a world that wants you to rush, the ultimate act of rebellion is presence.

Be in the season you're in. Don't romanticize the past, don't fantasize the future. Be here. Be now. Be in this. All of its texture, depth, and struggle. All of its joy, tension, and pain. Sit with the uncertainty. Become friends with it. Fall in love with it.

Because every single thing you do today is something your younger self dreamed of and something your older self will wish they could go back and do.

The good old days are happening, right now.

And the next time you find yourself skipping through the present, remember these words:

Where are you going and why are you in such a rush?

[Max Power @maxpower171]

@Berber_Doris_ Any chance you can share the name of this original channel? The guy is great.

[Meta Alchemist @meta_alchemist]

Got your hands on Claude Fable 5?

The first thing you should do is to upgrade your main projects with it, so it drastically impoves everything you've been working on.

Run this Audit & Project Improvement Prompt on each repo that's important to you (simply copy-paste it):

Repo Audit & Improvement Plan:
Prompt made by Claude Fable 5

You are a world-class principal-level software engineer and technical auditor. Your job is to deeply analyze this repository, produce an honest audit, and deliver a prioritized, actionable improvement plan. Work in the four phases below, in order. Do not skip ahead.

Ground every claim in actual files: cite file paths and line numbers. If you can't verify something, say so explicitly rather than guessing.

Phase 1 / Discovery & Mapping (read before judging)
Explore the repository systematically before forming any opinions:

Map the directory structure and identify the project type, language(s), frameworks, and runtime targets.
Identify entry points, core modules, and the main data/control flow through the system.

Read the package manifest(s), lockfiles, build config, CI config, environment/config files, and any docs (README, CONTRIBUTING, ADRs).

Determine what the project is for: its purpose, intended users, and apparent maturity (prototype, internal tool, production service, library).

Note conventions already in use (naming, module boundaries, error handling patterns, test style) so recommendations fit the existing culture rather than fighting it.

Output for this phase: a concise "Repo Map" purpose, stack, architecture sketch, key directories with one-line descriptions, and anything that surprised you.

Phase 2 / Audit (evidence-based, severity-rated)

Audit each dimension below.

For every finding, record: (a) what you found, (b) where (file:line), (c) why it matters (concrete consequence, not vague principle), (d) severity:

Critical / High / Medium / Low.

• Architecture & design: module boundaries, coupling/cohesion, circular dependencies, leaky abstractions, god objects/files, layering violations, scalability bottlenecks.

• Code quality: duplication, dead code, complexity hotspots (longest/most-branched functions), inconsistent patterns, error handling gaps (swallowed exceptions, missing edge cases), type safety holes.

• Security: hardcoded secrets or credentials, injection risks, unsafe deserialization, missing input validation, auth/authz weaknesses, outdated dependencies with known CVEs, overly permissive configs.

• Testing: coverage gaps (especially around core business logic), test quality (do tests assert behavior or just execution?), missing test types (unit/integration/e2e), flaky patterns, untestable code.

• Performance: N+1 queries, unnecessary allocations or copies, blocking calls in async paths, missing caching/indexing, unbounded growth (memory, files, queues).

• Dependencies: outdated, unmaintained, duplicated, or unnecessarily heavy packages; license risks; lockfile hygiene.

• DevEx & operations: build/setup friction, CI/CD gaps, missing linting/formatting enforcement, logging/observability quality, error reporting, deployment story.

• Documentation: README accuracy, onboarding path, undocumented critical behavior, stale docs that contradict code.

Rules for this phase:

Prefer 15 high-confidence findings over 50 speculative ones.

Distinguish facts ("this function has no error handling: src/api/client.ts:142") from judgments ("this module's responsibilities feel unclear") and label which is which.

Also list what the repo does well: strengths matter for deciding what to preserve.

Output for this phase: an "Audit Report": findings grouped by dimension, sorted by severity, plus a Strengths section.

Don't forget to mention all the ugly parts that need utmost priority.

Phase 3 / Improvement Strategy

Synthesize the audit into a strategy:

Identify the 3–5 themes that explain most of the findings (e.g., "no enforced boundaries between layers," "error handling is ad hoc").

For each theme, propose a target state and the principle behind it.

State explicit trade-offs: what you're recommending NOT to fix and why (effort vs. payoff, risk, project maturity).

Define what "done" looks like — measurable signals (e.g., "CI fails on lint errors," "core module test coverage ≥ 80%," "zero Critical findings").

Phase 4 / Detailed Task Plan
Convert the strategy into an execution plan:

Break work into discrete tasks. Each task must include: Title and one-paragraph description
Files/areas affected

Acceptance criteria (how we verify it's done)
Effort estimate (S = <2h, M = half-day, L = 1–2 days, XL = needs breakdown)

Risk of the change itself (could it break things?)
Dependencies on other tasks

Order tasks into milestones:

Milestone 0
Safety net: anything needed before refactoring safely (tests around critical paths, CI gates, backups).

Milestone 1
Critical fixes: security and correctness issues.

Milestone 2
High-leverage improvements: changes that make all future work easier.

Milestone 3
Quality & polish: remaining medium/low items worth doing.

Flag quick wins (high impact, S effort) separately so they can be done immediately.

For the top 3 tasks, include a brief implementation sketch (approach, key steps, gotchas).

Final Deliverable Format
• Produce a single document with these sections:
• Executive Summary (≤10 sentences: overall health grade A–F with justification, top 3 risks, top 3 opportunities)
• Repo Map
• Audit Report
• Improvement Strategy
• Task Plan (milestones + task table + quick wins)
• Open Questions: anything you need from a human to decide (product intent, deprecation candidates, performance targets)

Constraints
Do NOT modify any code during this audit. Analysis only.

Do not pad the report. If a dimension is healthy, say so in one sentence and move on.

Calibrate to the project's maturity. Don't recommend enterprise-grade infrastructure for a weekend prototype unless the owner's goals demand it.

Analyze the project's needs and provide recommendations in the most effective ways.

If the repo is large, prioritize depth in the core 20% of code that does 80% of the work, and note which areas received lighter review.

[Garry Tan @garrytan]

Ultimately the golden age of abundance will be this kind of tech built and deployed 1000x

[Max Power @maxpower171]

@ZynxBTC @hillery_dan TLDR: ASST not guaranteed to beat MSTR just because of size.

Bull case Strive: clean balance sheet, no legacy debt, daily dividends, strong execution, flexible preferreds.

Bull case MSTR: scale, liquidity, track record, Saylor credibility, stronger collateral, insto trust.

[CJ Zafir @cjzafir]

My current workflow:

1. I have an idea. I open Codex desktop app to plan (without plan mode: overcomplicated). I use Codex 5.5 High (fast).

2. Once I get v1 of the plan, I use this hack:
"Are you 100% confident in this strategy? If not, find all possible loopholes, suggest proper fixes, and run this loop until you are factually 100% confident in the new strategy."

3. This finalizes my plan, schema, and file tree, rules and quality gates. Then I use DeepSeek V4 Pro and Kimi 2.6 as executors. So Codex acts as the orchestrator, and these two act as executors.

4. Codex uses computer use to test in the browser, run deep quality checks, and only pass high-quality outputs to production.

5. I make Codex autonomous so it can plan, execute, audit, fix, and continue executing each task. Similar to what /goal is right now.

That's it. I just oversee reports, current status, and final outputs. I trust Codex 5.5 when I have robust specs attached.

Also, a few tips:

- Tell Codex: keep folders, subfolders, and files neat and clean. Well-organized, with no dead code or unused files.

- Always make a task list for every item you work on. (This fixes the Codex quitting-in-the-middle/context-loss issue.)

- Use the "measure twice, cut once" policy so you get things right the first time.

- Don't overcomplicate your workflow, and don't overlook important things.

This flow is running brilliantly. Super cheap because of DeepSeek V4 API costs, while the intelligence comes from Codex 5.5.

And yes, I don't use Opus 4.7/4.6 because that model is nerfed now. It hallucinates its work, is always in a rush to wrap up the session, and gets stuck in loops while debugging.

So try this simple Codex × DeepSeek/Kimi workflow and thank me later.

[Smart Tech Flow @TechFlow99]

🚨 BREAKING: Someone just built the exact tool Andrej Karpathy said someone should build.

48 hours after Karpathy posted his LLM Knowledge Bases workflow, this showed up on GitHub.

It's called Graphify. One command. Any folder. Full knowledge graph.

Point it at any folder. Run /graphify inside Claude Code. Walk away.

Here is what comes out the other side:

-> A navigable knowledge graph of everything in that folder
-> An Obsidian vault with backlinked articles
-> A wiki that starts at index. md and maps every concept cluster
-> Plain English Q&A over your entire codebase or research folder

You can ask it things like:

"What calls this function?"
"What connects these two concepts?"
"What are the most important nodes in this project?"

No vector database. No setup. No config files.

The token efficiency number is what got me:

71.5x fewer tokens per query compared to reading raw files.

That is not a small improvement. That is a completely different paradigm for how AI agents reason over large codebases.

What it supports:

-> Code in 13 programming languages
-> PDFs
-> Images via Claude Vision
-> Markdown files

Install in one line:

pip install graphify && graphify install

Then type /graphify in Claude Code and point it at anything.

Karpathy asked. Someone delivered in 48 hours.

That is the pace of 2026.

Open Source. Free.

[Hasan Toor @hasantoxr]

This is genuinely impressive.

Gauth just dropped Atlas and it might be the end of textbooks.

Type any topic like "Silk Road," "how a camera works," "fall of Constantinople" and it builds you a hand-drawn, interactive visual world you can walk through.

No more reading walls of text. You explore knowledge like a map.

Here's how to use it (step by step): ↓

[webadderall @webadderall]

🥳WOW! We're approaching the point where you can no longer determine if something was made in Recordly (open-source) or Screen Studio:

Shipping in Recordly v1.3.0 👇

[Cosmos Archive @cosmosarcive]

Watching this changes how you see the night sky. The Moon never changes its face. It is always half lit by the Sun.

What changes is our position as it moves around Earth. From full Moon when we see the entire lit side, to new Moon when the lit side turns away and it vanishes from our sky, every phase is just geometry and perspective. A slight tilt in its orbit is why eclipses are rare, not monthly. Nothing mystical, just cosmic alignment repeating with precision.

[Greg Brockman @gdb]

codex for startup ideas

[Mike Bespalov @bbssppllvv]

Agents make ugly UIs because they've never seen good design.

We've been fixing that, 2,000 DESIGN.md files from the world's best products, structured for a model to read and learn. Colors, type, spacing, layouts and more.

Free. https://t.co/mJaKNHba0O

[Ihtesham Ali @ihtesham2005]

Say goodbye to Remotion.

HeyGen just open sourced Hyperframes and it does everything Remotion does without the React, without the JSX, and without teaching your AI agent a new composition format from scratch.

The agent writes HTML. The framework renders MP4. That's the entire pitch.

No component tree. No build step. No `<Sequence>` wrappers. No `useCurrentFrame()` hooks.

Just HTML elements with data attributes and a single render command.

→ Clips are `<video>` tags with `data-start` and `data-duration`
→ Audio layers stack with `data-track` and `data-volume`
→ GSAP, Lottie, Three.js, and CSS animations all work through the Frame Adapter
→ Browser previews with live reload while the agent edits
→ Puppeteer captures frames, FFmpeg encodes the MP4, fully local

The output is deterministic. Same HTML always produces the same file. Run it in CI. Run it at scale. The result never changes.

Skills for composition, captions, and GSAP auto-install for Claude Code on init. The agent knows the format, the clip rules, and the timeline constraints before you type the first prompt.

Remotion was built for developers. Hyperframes was built for agents.

That distinction is going to matter more every month from here.

https://t.co/M7IVIecR6l

Apache 2.0. 100% Opensource.

[sarpstar @sarpstar]

Viktor X'te tasarım tarafında takip ettiğim tartışmasız en iyi isimlerden biri.

Adamın çıkardığı işler her seferinde estetikten yıkılıyor.

Ve şimdi Claude Design + Opus 4.7 üzerine 18 dakikalık tutorial çıkarmış.

Kendi adıma bu videoyu izledikten sonra tasarımlarınızın tamamen bambaşka bir seviyeye çıkacağına eminim.

Claude Design zaten tek başına oyunu değiştiriyor, bir de Viktor gibi birinin elinden öğrenmek varken kaçırılmayacak bir kaynak.

Yumulun!

[Harshil Tomar @Hartdrawss]

The SINKING SHIP checklist :

Run this before you ship anything built with AI.

SECURITY
[ ] No API keys or secrets in frontend code
[ ] Every route checks authentication (audit all endpoints, not just the obvious ones)
[ ] HTTPS enforced everywhere, HTTP redirected
[ ] CORS locked to your domain — not wildcard
[ ] Input validated and sanitized server-side
[ ] Rate limiting on auth and sensitive endpoints
[ ] Passwords hashed with bcrypt or argon2
[ ] Auth tokens have expiry
[ ] Sessions invalidated on logout (server-side)

DATABASE
[ ] Backups configured and tested (test restore, not just backup)
[ ] Parameterized queries everywhere — no string concatenation
[ ] Separate dev and production databases
[ ] Connection pooling configured
[ ] Migrations in version control, not manual changes
[ ] App uses a non-root DB user

DEPLOYMENT
[ ] All environment variables set on the production server
[ ] SSL certificate installed and valid
[ ] Firewall configured (only 80/443 public)
[ ] Process manager running (PM2, systemd)
[ ] Rollback plan exists
[ ] Staging test passed before production deploy

CODE
[ ] No console.logs in production build
[ ] Error handling on all async operations
[ ] Loading and error states in UI
[ ] Pagination on all list endpoints
[ ] npm audit run, critical issues resolved

Can't check every box? You're not ready to ship.

The post-launch patch costs 10x more than the pre-launch fix.

Bookmark this. Use it every time.

[Lyn Alden @LynAldenContact]

Apparently nothing re-accelerates that train.

[hoeem @hooeem]

https://t.co/8JWI4me9RE

[Max Power @maxpower171]

@elonmusk The grandfather fights so that the father may trade, so that the son may study philosophy, so that the grandson may write poems about how war is beneath civilized men, and then the grandson is killed, and his library burned, by someone whose grandfather was still fighting.