Top Results (0)

Hey there! I’m glad you found Cryptolinks—my personal go-to hub for everything crypto. If you're curious about Bitcoin, blockchain, or how this whole crypto thing works, you're exactly where you need to be. I've spent years exploring crypto and put together the absolute best resources, saving you tons of time. No jargon, no fluff—just handpicked, easy-to-follow links that'll help you learn, trade, or stay updated without the hassle. Trust me, I've been through the confusion myself, and that's why Cryptolinks exists: to make your crypto journey smooth, easy, and fun. So bookmark Cryptolinks, and let’s explore crypto together!

BTC: 111036.64
ETH: 3997.13
LTC: 95.17
Cryptolinks: 5000+ Best Crypto & Bitcoin Sites 2025 | Top Reviews & Trusted Resources

by Nate Urbas

Crypto Trader, Bitcoin Miner, Holder. To the moon!

review-photo

David Schwartz

twitter.com

(3 reviews)
(3 reviews)
Site Rank: 20

David Schwartz (@JoelKatz) Review Guide: Everything You Need To Know + FAQ

David Schwartz (@JoelKatz) Review Guide: Everything You Need To Know + FAQ


Why do so many crypto folks hang on every @JoelKatz tweet—and how do you make sure you’re getting signal instead of noise?


If you’re in XRP, tracking XRPL development, or just watching how real-world payments are moving onto blockchains, David Schwartz is a must-follow. He’s one of the most visible technical voices in crypto, and his posts can teach you more about what’s actually shipping than a week of headlines.


In this guide, I’ll show you how to read his posts the smart way, what to ignore, and where to verify what matters. Think of this as your friendly map to a very loud corner of crypto X/Twitter.


Describe problems or pain


Let’s be real: it’s easy to get lost here.



  • Headlines contradict each other. One outlet says a feature is live; another says it’s months away. The truth is usually in the specs and repos, not the hype.

  • There are multiple “David Schwartzes.” People often mix up @JoelKatz with the TV/film composer David Schwartz (IMDb), and there are impersonator accounts too. X even has an explicit impersonation policy because of how common it is.

  • Rumors around XRP spread fast. A classic pattern: someone screenshots an out-of-context reply, adds a spicy caption, and it’s “breaking news.” The MIT study on misinformation found false news on Twitter spreads farther, faster, deeper, and more broadly than the truth—especially for political and finance content (Science, 2018).

  • If you don’t speak protocol, it’s hard to tell what’s real. Terms like “amendment,” “consensus,” and “validator votes” matter. Without that context, a joke can look like a roadmap update.



“Did you see that tweet? Feature X is live tomorrow!”

Not necessarily. Sometimes it’s a testnet note, a standards discussion, or just humor.

To make it trickier, crypto audiences often get news on social feeds. Pew Research has repeatedly shown that a meaningful share of adults get news from social platforms, which raises the risk of misreads when posts are short and fast-moving (Pew Research Center).


Promise solution


Here’s what I’m going to do for you: give you a clear, practical review of @JoelKatz—his role, track record, the topics he actually posts about, how to verify claims in minutes, and where to find updates that matter. No drama, no guesswork—just a simple way to get smarter from a top technical voice.


Who this guide is for



  • You hold XRP and want clean context without the echo chamber.

  • You build on or explore XRPL and need reliable pointers to features and timelines.

  • You follow Ripple and want to separate company talk from protocol reality.

  • You’re crypto-curious and prefer trustworthy explanations over hype.


What you’ll get



  • A friendly overview of who @JoelKatz is and why his posts get attention.

  • Links to credible sources you can bookmark—think official docs and reputable outlets, not random threads:

    • @JoelKatz on X

    • XRPL.org

    • XRPL Foundation

    • Ripple blog

    • The Block and CoinDesk for fast checks



  • A myth-busting FAQ so you don’t mix up people, roles, or old headlines.

  • A simple checklist to follow his feed without getting pulled into rumor loops.


Ready to get the simple, no-nonsense read on who David Schwartz actually is—and why his posts move conversations across XRP and real-world payments? Let’s start there next.

Who is David Schwartz (aka @JoelKatz)?


David Schwartz is best known as a long-time technical leader at Ripple and one of the original architects of the XRP Ledger (XRPL). On X/Twitter he goes by @JoelKatz, where he takes heavy protocol concepts and turns them into plain-English explanations that humans can actually use.


“In crypto, clarity beats hype. The code either ships, or it doesn’t.”

Roles and background


Schwartz’s fingerprints are all over XRPL’s foundations and its public education efforts. A quick sketch of why people listen when he talks:



  • XRPL architect: Co-authored the early consensus paper for what became the XRP Ledger’s approach to agreement and finality (Ripple Consensus Whitepaper, 2014).

  • Ripple technical leadership: Served as the company’s senior technical voice for years, shaping priorities around payments, tokenization, and reliability.

  • Public explainer: Uses @JoelKatz to break down amendments, standards (XLS), and real trade-offs—often with links to specs, repos, or validator processes.

  • Standards and governance guide: Frequently points the community to XRPL’s amendment process and why changes need testing and validator support before they’re “live.”


Why he matters in crypto


XRPL’s design targets fast finality, low fees, and predictable performance for payments and tokenized assets. Schwartz helped shape how that works in practice—especially around consensus, amendments, and features that support on-ledger markets.



  • Consensus that aims for speed and reliability: The XRP Ledger uses a variant of federated Byzantine agreement, documented early by Schwartz and later analyzed in independent research (Chase & MacBrough, arXiv). The result: ledger closes typically complete in a few seconds with finality designed for production payments (XRPL consensus overview).

  • Payments-first features: Low, deterministic fees and an amendment framework geared to ship useful upgrades without breaking existing behavior (Amendments 101).

  • Real examples you can check right now:

    • On-ledger AMM (XLS-30): A natively integrated automated market maker built around continuous auctions and liquidity pools. See the docs and references to the auction design and invariants (XRPL AMM).

    • NFTs (XLS-20): Native issuance and trading of NFTs with specific transaction types and reserve logic crafted for XRPL’s throughput and ledger model (XRPL NFTs).

    • Clawback: Opt-in controls for certain issued assets, useful for compliance-bound tokens and enterprise scenarios (Clawback).

    • Sidechains concept: A path to experimentation without risking mainnet stability, discussed openly with the community (Federated Sidechains proposal).




If you want a quick “why him?” answer: he blends protocol authorship with public accountability. He explains the trade-offs, not just the wins, and points people to the exact specs or code that back up the claims.


About recent headlines


Every now and then, you’ll see headlines suggesting he’s stepping down, changing roles, or shifting focus. Treat those as time-sensitive and verify before you decide what it means.



  • Check primary sources first: His own account @JoelKatz and Ripple’s official channels (Ripple Insights / Newsroom).

  • Cross-reference independent coverage: Reputable outlets that correct quickly when details change (e.g., The Block).

  • Look for the paperwork: Material changes that affect XRPL often show up in repos, amendment trackers, or XRPLF updates (XRPL.org).


One reason this matters: the market loves to react to headlines. But XRPL itself moves through a very public amendment and validator process. When Schwartz talks about a feature, I look for the matching spec or code path. If it’s not there yet, it’s probably still a conversation—not a change.


You know who someone is. Next question: how do you read his posts so you catch the signal and skip the noise? I’ll show you the exact cues I look for in his threads, the kind that separate a thoughtful roadmap hint from a spicy meme. Ready for the shortcuts?

Reading @JoelKatz on X/Twitter the smart way


When I open David Schwartz’s feed, I’m not looking for hype. I’m looking for clues. Protocol breadcrumbs. Pointers to what’s actually shipping on XRPL and what’s just chatter. If you read @JoelKatz the smart way, you’ll catch the signal long before the headlines catch up.



“On X, context is your edge; speculation is a tax.”

What he posts (and what it means)


His posts mix engineering notes, governance context, and the occasional one-liner. Here’s how I translate them:



  • XRPL feature explainers: Mentions of AMM, Hooks, sidechains, XLS-20 NFTs, Clawback. If he links to a spec or repo, it’s a nudge to read the source. Start with XRPL Standards and rippled on GitHub.

  • Governance updates: Language like “amendment,” “majority,” or “enabled” has concrete meanings on XRPL. Cross-check with Known Amendments to see status.

  • Security and reliability takes: If he’s talking about trade-offs, fees, or validator behavior, assume it’s a lesson in how XRPL avoids footguns. These posts help you understand why features roll out the way they do.

  • Standards talk: References to XLS numbers (like XLS-20) are about how new capabilities are specified, reviewed, and implemented. Specs > soundbites.

  • Industry clarifications: He often corrects assumptions around Ripple/XRP/XRPL. Treat those clarifications as guardrails for your own research.


Quick translation guide I use:



  • “Here’s the spec” = It’s in review/definition. Not live.

  • “Available on Devnet/Testnet” = Time to experiment, not ape. See XRPL dev networks in the docs.

  • “Amendment has a majority” = Validators are signaling; watch for the majority window before mainnet enablement.

  • “Enabled on mainnet” = That’s the only moment that matters for production usage.


How to separate signal from noise


The fastest way to misread @JoelKatz is to treat every sentence as a roadmap. Here’s the filter I use:



  • Prioritize threads over one-liners. If he’s posting a numbered thread or replies to himself, that’s usually the “teaching” mode with context.

  • Hunt the links. GitHub PRs, XLS proposals, or XRPL.org pages signal real movement. Memes and sarcasm add color, not confirmation.

  • Spot the framing. Words like “personally,” “I think,” or scenario-based hypotheticals usually indicate opinion, not a rollout plan.

  • Check for code nouns. If he names an amendment, function, or repo file path, that’s your cue to verify the source and version.

  • Beware of screenshots. If the signal is a cropped screenshot versus a link, I assume it’s incomplete until I find the original post or repo.


Why I’m this strict: peer‑reviewed research repeatedly finds that social sentiment on X/Twitter correlates with crypto volatility and short‑horizon returns. That means hot takes can move markets—right or wrong. If you want receipts, search Finance Research Letters or Google Scholar for “Twitter crypto sentiment price” and you’ll find multiple studies across 2018–2022 showing this relationship. My remedy is simple: verify before you act.


Notifications and Lists


If you don’t want to live on X, build a smart radar:



  • Turn on thread notifications. Tap the bell on @JoelKatz and set it to “Posts” or “All” so you catch the multi‑post explainers.

  • Create an “XRPL Core” List. Add @JoelKatz, @RippleXDev, XRPL Foundation, and builders like Wietse Wind. A focused List gives you context around his posts without the full firehose.

  • Use X Pro (TweetDeck) columns. Set columns for:

    • from:joelkatz (AMM OR Hooks OR XLS OR sidechain)

    • from:joelkatz filter:links github.com (catches code/spec links)

    • (XRPL OR “XRP Ledger”) (amendment OR XLS) (broader standards chatter)



  • Bookmark the source-of-truth tabs:

    • XRPL Known Amendments

    • rippled release notes

    • XRPL Standards pull requests




These simple setups make you the person who sees the spec link and the implementation status—not just the screenshot of a hot take.


Verify before you act


When something sounds big—timelines, upgrades, departures—here’s my checklist to keep emotions in check:



  • Find the primary link. If there’s no XRPL.org doc, XRPLF repo, or Ripple post, you’re probably early or off base.

  • Confirm amendment status. Use Known Amendments and recent rippled releases. If it’s not listed, don’t treat it as live.

  • Look for a dev/testnet mention. If it’s on Devnet/Testnet, great—test it. Use the faucet and guides on XRPL.org to validate behavior yourself.

  • Cross‑check reputable media. See if The Block, CoinDesk, or Decrypt corroborate—and whether @JoelKatz links or clarifies.

  • Time discipline. For anything market‑moving, wait for a spec + implementation + amendment status. One tweet is not a go‑signal.


Real talk: I’ve saved more money by waiting for an amendment to show “enabled” than I’ve ever made trying to front‑run a rumor. If a post truly matters, it survives the verification phase.


Want to know which XRPL features he returns to again and again—and why those matter for speed, fees, and reliability? Keep reading; that’s where this gets practical fast.

What David Schwartz is known for in the XRPL ecosystem


I watch how new XRPL features move from idea to implementation, and I see the same thread every time: David Schwartz keeps pulling the conversation back to reliability, safety, and why certain trade-offs exist. If you care about payments that settle in seconds and assets that can live on a battle-tested ledger, this is the lens you want.



“Speed without safety is just a countdown to downtime.”

Consensus and reliability focus


XRPL’s consensus model is built for fast finality and low fees—without mining. Instead of proof-of-work, it uses a set of trusted validators (your Unique Node List) to reach agreement in a few seconds. That’s why payments on XRPL feel instant and predictable.


What I’ve picked up from Schwartz’s posts over the years:



  • Deterministic settlement: When a transaction is validated, it’s final. That’s critical for remittances and treasury ops where reversals are unacceptable.

  • 80%+ validator threshold: Protocol changes require supermajority support for two weeks before they go live, reducing the chance of rushed rollouts and chain splits. See the live status on XRPSCAN Amendments.

  • Fault tolerance in practice: Features like the Negative UNL help the network keep moving even if some validators go offline—again, reliability over hype.


If you’re comparing consensus designs, XRPL’s approach prioritizes uptime and finality for real-world money flows. It’s not flashy; it’s stable by design—exactly the sort of thing Schwartz tends to defend when Twitter wants drama instead of engineering.


Features he often discusses




  • AMM (Automated Market Maker) on XRPL: The AMM proposal (often referenced as XLS-30) aims to make native liquidity pools a first-class citizen on the ledger. It uses a continuous auction mechanism to let arbitrageurs keep pools balanced while sharing incentives with LPs—right on L1.

    Real example: Think of an XRP/USD pool where fees auto-adjust via auctions. Traders get tight spreads without leaving XRPL; LPs earn yield without wrapping assets on a side chain. Watch the amendment’s progress via validator votes before assuming it’s “live.”


  • Clawback (issuer-controlled recovery): For issued tokens (IOUs), an issuer can optionally enable a clawback flag at creation. This is about compliance and damage control in the worst cases—say a stablecoin issuer needs to recover funds from a hacked address. It only works if the trust line was set with clawback permitted from the start.

    Real example: A fintech pilot issues a USD token and sets clawback. If its hot wallet is compromised, it can claw back those tokens to protect users while following published rules. That’s not censorship; it’s an opt-in policy tool communicated up front.


  • XLS-20 NFTs (on-ledger NFTs):NFT support landed on mainnet after extensive testing and delay for fixes—a textbook case of “ship when it’s safe.” Creators can mint, list, and set transfer fees natively, without side contracts. Check the official docs on XRPL.org.

    Real example: Collections use transfer fees for creator royalties that execute at the protocol level, reducing marketplace risk and fragmentation.


  • Sidechains and Hooks: Federated sidechains let you experiment without risking mainnet stability. Hooks (currently on testnets) add lightweight, event-based logic right where assets live—great for spending limits, compliance checks, or loyalty redemptions without a full smart-contract VM.

    Real example: A payments sidechain runs custom logic for a region’s rules, while bridging back to XRPL for liquidity. Builders iterate fast; mainnet stays stable.


  • Interoperability (bridges, standards): Expect references to cross-chain standards (like XLS proposals for bridges) and how they’re reviewed. The goal is consistent, predictable transfers across chains without creating new failure points.


  • Amendment process: Features are shipped through amendments—proposed, tested, voted, then activated with a supermajority. Schwartz often reminds folks: test first, verify votes, don’t trade on assumptions.


Governance and standards


When he talks governance, it’s rarely about personalities. It’s about process:



  • Specs first: Proposals live in the XRPL-Standards repo. Read the XLS, not just a screenshot thread.

  • Code second: Implementation lands in rippled, the reference server. If it isn’t in code or an open PR, it’s not close.

  • Testnets matter: XRPL Devnet/Testnet catch issues before mainnet. Schwartz routinely nudges devs to try features there first. See public networks on XRPL.org Public Servers.

  • Validator majority and time: A 2-week majority isn’t bureaucracy; it’s a stress test against operational reality. Many “coming any day” rumors die here—for good reason.


There’s a reason this process tends to hold up under pressure: it forces proposals to earn their way through review, testing, and adoption. When Schwartz explains this, he’s not gatekeeping—he’s protecting users from rushed changes that break money flows.


Practical takeaways for users and builders



  • Verify amendment status: Before you rely on a new feature, check votes and live status on XRPSCAN and XRPL.org Amendments.

  • Read the XLS you’re building against: Find the relevant proposal in XRPL-Standards. Specs change; tweets don’t always capture the latest.

  • Prototype on testnet/devnet: Use public test networks to simulate real flows—NFT mints, AMM LP deposits, clawback paths, bridge trials. Document your edge cases.

  • Respect issuer flags and contracts: If you issue tokens, publish clawback and freeze policies up front. If you hold them, check trust line settings before integrating.

  • Watch for reference tooling: When Schwartz hints at upgrades, also watch for SDK updates (xrpl.js, xrpl-py) and wallet support (Xumm, etc.). Feature support across tools is your real “go” signal.


If you’ve ever wondered why seasoned XRPL builders seem calm when timelines slip, it’s because they’ve learned the culture: measure twice, cut once, and don’t let hype ship your code. Ready for the most-Googled questions and a few myths that never seem to die?

Common questions and myths (FAQ-ready)


I keep getting the same questions about @JoelKatz, so here are the straight answers I wish someone gave me when I started tracking XRPL and Ripple news.



“Trust, but verify.”

“Who is David Schwartz XRP?”


He’s widely known as Ripple’s long-time technical leader and a key architect behind the XRP Ledger (XRPL). Most people know him by his handle @JoelKatz, where he explains protocol choices, amendment timelines, and clears up rumors in plain English.


If you’ve seen talk about role changes or transitions, treat that as time-sensitive. Before you repeat it, check:



  • His X account: @JoelKatz

  • XRPLF or XRPL.org updates: xrpl.org

  • Reputable crypto outlets (e.g., The Block, CoinDesk)


One tip to save you from scams: there are countless impersonators across X, Telegram, and YouTube. The real account is the one linked above. Anything asking you to send XRP is not him.


“What is David Schwartz known for?”


In crypto, he’s most associated with shaping XRPL’s technical approach: speed, finality, and reliability for real-world payments and tokenization. He frequently talks through decisions around consensus, amendments, and standards—often pointing to specs or code so you can verify for yourself.



  • XRPL architecture and consensus: If you want to get nerdy, there’s academic work analyzing the Ripple/XRPL consensus model, including performance and safety trade-offs. See: Armknecht et al., “On the Security and Performance of the Ripple Consensus Protocol” (IACR).

  • Standards and features: He often comments on drafts like XLS-20 (XRPL NFTs) and upgrades like the built-in AMM, explaining how they move from proposal to production via amendments.


Important: there’s also a David Schwartz who’s a TV/film composer. Totally different person. If you end up on IMDb, you took a wrong turn.


“Who is JoelKatz?”


JoelKatz is David Schwartz’s long-standing handle on X. When people say “JoelKatz said…,” they mean a post from @JoelKatz. It’s the primary public feed where he shares technical notes, clarifications, and the occasional dry joke that sometimes gets misread as policy. When in doubt, check if he links to a spec, amendment ID, or GitHub—those are the posts that usually matter most.


“What did David Schwartz do?”


Community credit ties him to the early design and ongoing evolution of the XRP Ledger. He’s known for translating complex protocol decisions into understandable language and nudging the ecosystem toward careful testing and standards-driven releases.



  • Historical context: XRPL’s early history involves a small group (including David Schwartz, Jed McCaleb, and Arthur Britto) who set the direction away from Proof-of-Work toward a different consensus path. For a timeline and references, see XRPL.org: History.

  • Practical impact: His public posts often foreshadow what’s coming to testnet/devnet and, later, mainnet—once validators approve an amendment. You’ll see him remind folks to wait for votes and to test before assuming a feature is live.


Seen headlines about a change in title or responsibilities? Good instinct is to pause until you can match it to a primary source like his X thread, a Ripple/ XRPLF post, or a code repo reflecting the change.


Quick myth checks:



  • “He can flip a switch and change XRPL.” No. Major changes require proposals, testing, and validator voting through the amendment process. Track live status here: Known Amendments.

  • “A single tweet equals a confirmed roadmap.” Treat tweets as context until they’re backed by specs, repos, or official posts.

  • “All ‘David Schwartz’ accounts are him.” Only @JoelKatz is the real one on X.


If a post sounds market-moving, do you know the fastest way to confirm it in under a minute without getting spun by hype or haters? Keep reading—next up, I’ll share the exact fact-check flow I use and the sources that never waste my time.

How I fact-check and keep perspective on @JoelKatz


I’ve got one rule that saves me from getting whiplash when @JoelKatz tweets something spicy: if it’s not in code, votes, or docs, it’s not confirmed. Here’s exactly how I sanity-check what I see—quickly, calmly, and with zero drama.



Rule of thumb: A post can be insightful without being a green light. I look for proofs in repos, specs, release notes, and validator votes before I treat anything as “real.”



Cross-check with core sources


When I see a claim—new feature, timeline, security nuance—I triangulate it against the XRPL’s living record. These are the pages I keep pinned:



  • Docs and specs: XRPL.org (especially Features, Standards, and Known Amendments)

  • Core code and releases: XRPLF/rippled + rippled releases

  • XLS proposals: XRPL-Standards (e.g., XLS-20 for NFTs, XLS-30 for AMM)

  • Validator + amendment status: Known Amendments, XRPScan Amendments, validators.xrpl.org

  • Official posts: XRPLF announcements and the Ripple blog


Real example: if David hints that an XRPL AMM tweak is “ready,” I check whether there’s a corresponding PR in rippled, a spec update under XRPL-Standards, and evidence of validator voting on an amendment. If all I find is discussion, it’s an idea—not a rollout.


Watch the amendment process


XRPL changes aren’t hand-wavy; they’re gated. The steps I look for:



  • Spec and code: There’s usually an XLS plus a rippled PR or merge. Bonus points for release notes.

  • Feature flag: The code lands behind a named amendment. You’ll see it on the Known Amendments page and explorer dashboards.

  • Validator consensus: A supermajority (commonly 80%) supports it consistently (commonly ~2 weeks). Dashboards help verify this.

  • Activation: Once the threshold window is met, the amendment activates on mainnet. That’s the “it’s live” moment.


Why this matters: Tweets can be ahead of the process. “Ready” might mean the code exists. “Coming” might mean testnet-only. I don’t treat anything as production-grade until I can point to a specific amendment with a visible vote and activation path.


Practical check: When XLS-30/AMM discussions were hot, I watched XRPScan’s Amendments and validators.xrpl.org for real voting data and cross-referenced with rippled release notes. If the dashboards didn’t show sustained supermajority, I tagged it as “not shipped.”


Track credible media


I compare reporting from outlets with editors and sourcing standards, then look for a primary confirmation:



  • Match the headline against the code/spec state and amendment dashboards

  • Scan for a direct quote or post from David

  • Look for an official note from Ripple or XRPLF


Example scenario: rumors about leadership transitions or timelines. If there’s no statement on David’s X account, no note on the Ripple blog, and no corroboration from a reputable outlet, I file it under “interesting—but not actionable.”


Keep emotion out of it


Twitter can amplify hot takes, and that’s where mistakes happen. I use a simple signal system to keep my head clear:



  • Red (discussion): It’s an idea/opinion. No code, no spec, no votes.

  • Yellow (in motion): Code merged or on testnet/devnet. Spec exists. Amendment proposed, not activated.

  • Green (activated): Votes hit threshold, amendment active, release notes published.


Two quick habits help a lot:



  • 30-minute rule: I wait at least half an hour before posting or trading on “breaking” tweets. It’s enough time to check dashboards and repos.

  • Accuracy nudge: I ask one question before sharing: “What’s the proof?” Research shows this works. False news spreads faster than truth on Twitter (Vosoughi, Roy, Aral, Science 2018), and prompting accuracy reduces sharing of misinformation (Pennycook et al., Nature 2021).


Pro tip: when I’m unsure, I search David’s posts directly using X advanced search (e.g., from:JoelKatz “amendment” filter:threads) and then line it up against the Known Amendments list and XLS repo. If the language in a tweet doesn’t match the spec terms, I assume it’s shorthand, not a spec change.


Want the exact one-minute checklist I use to go from “tweet” to “trusted info” without doomscrolling or FOMO? That’s up next—curious to see how fast you can verify the next headline?

Your quick-start plan to follow @JoelKatz the right way


Want the signal without the scroll? Here’s the simple system I use to keep up with @JoelKatz and turn his posts into practical insight instead of noise.


Quick checklist



  • Follow @JoelKatz and turn on notifications. For long threads, use the thread notification option when available.

  • Create a “XRPL Core” List so you get context around his posts. Add:

    • @XRPLF (XRPL Foundation)

    • @Ripple

    • @RippleXDev (dev updates)

    • @XRPScan (explorer and amendments tracking)



  • Bookmark verification links so you can check claims in seconds:

    • XRPL known amendments: xrpl.org/known-amendments.html

    • Core node repo (rippled): github.com/XRPLF/rippled

    • XRPL Standards (XLS): github.com/XRPLF/XRPL-Standards

    • XRPL Foundation blog: foundation.xrpl.org/blog/

    • XRPScan amendments page: xrpscan.com/amendments



  • Save two quick X searches for fast filtering:

    • from:JoelKatz (amendment OR XLS OR vote OR rippled)

    • from:JoelKatz (AMM OR Hooks OR sidechain OR NFT)




What to do when you see a big claim


First, breathe. Social feeds push urgency, but crypto rewards patience.



Rule of thumb: If it’s not in a spec, amendment, or repo, it’s not confirmed rollout. Treat it as a hint until you can verify.

Here’s my 60–90 second routine:



  • Check status: Is there an entry on Known Amendments or a PR/commit in rippled?

  • Look for a standard: Is there an XLS proposal or discussion in XRPL-Standards?

  • Scan a trusted outlet: Has a reputable publication summarized it yet? If yes, compare the article with the source post.

  • Check amendment trackers: See live status on XRPScan (Enabled, Vetoed, Waiting for Majority, etc.).


Example: If he hints the AMM patch is “ready,” I glance at the rippled PRs, look for any AMM-related entries in Known Amendments, and see whether XRPScan shows voting activity. If none of that is visible, I treat it as “work in progress,” not production-ready.


Why pause? A well-cited study in Science (MIT, 2018) found false news spreads faster than truth on Twitter because novelty grabs attention. Translation: speed can work against accuracy. A 1-minute check saves a lot of stress. Source: science.org/doi/10.1126/science.aap9559


If it feels market-moving: wait for confirmation from at least one primary source (XRPL docs, XRPLF, Ripple) before making decisions.


Extra tip for builders and power users



  • Test on official networks:

    • XRPL Testnet faucet: xrpl.org/xrp-testnet-faucet.html

    • Devnet overview: xrpl.org/devnet.html



  • Track proposals “in the wild”: Watch discussions and issues in XRPL-Standards and rippled issues to see how ideas evolve before they hit mainnet.

  • Join the community hub: XRPL Discord is great for real-time context and testing help: discord.gg/xrpl

  • Keep a tiny lab notebook: note the tweet, the spec link, your test steps, and whether it worked on Testnet/Devnet. This makes you faster next time.


Final take


Use his feed as a compass, not a siren. Follow, organize, verify, and test. With a short checklist and a couple of trusted links, you’ll turn @JoelKatz’s posts into clear, actionable understanding—without getting pulled into rumor cycles.



CryptoLinks.com does not endorse, promote, or associate with Twitter accounts that offer or imply unrealistic returns through potentially unethical practices. Our mission remains to guide the community toward safe, informed, and ethical participation in the cryptocurrency space. We urge our readers and the wider crypto community to remain vigilant, to conduct thorough research, and to always consider the broader implications of their investment choices.

Pros & Cons
  • David Schwartz replies tweets directed at him which shows how reliable he can be when it comes to making enquiries
  • His tweets are very informative