Launching Coii for @EFDevcon
don't waste your time at devcon8
find your tribe beforehand,
- connect on similar ideas/tracks
- watch which narrative wins before event in real time
- create your own "adda" to meet people at Devcon8
built with love by @DecipherClub
Decipher Club retweeted
You are in a market that does not let you Sell.
Imagine a market that sells coffee beans, and you are one of its registered sellers.
You have good beans, lower prices, better packaging, etc.
But.... You are unable to sell.
Why - coz buyers never see you.
Why?
Because in this market, buyers do not browse.
Every buyer request goes through a discovery desk, and the operator sitting at that desk decides which sellers a buyer is shown.
So you walk up to him and ask why you are never on that list:
- You: Why do buyers never see my shop?
- Operator: Because you do not rank high enough in seller's.
- You: What do I need to rank higher?
- Operator: Sales volume, and a list of customers who have already bought from you.
- You: But I can only get those if buyers find me and buy from me first.
- Operator: Correct. And buyers only find you once you rank high enough.
Meanwhile, the largest coffee seller in the market has already taken that order.
The buyer never saw your shop.
The operator says - "not my problem"
The market worked exactly as designed.
Would you keep selling in that market?
Would you tell another merchant to come and join you in it?
That is the condition of open agentic markets today.
Today, the open agentic commerce market is killing its own merchants - and hence the market itself.
article below 👇
Decipher Club retweeted
If you are a programmer, stop obessing over what is optimal to study/upskill in.
Engineers with staying power have depth in a lot of areas.
The goal is to have a deep and wide understanding of software engineering, not to pick a "shortcut subject"
Pick a subject and stick with it for 90 days.
Be a learning machine, not a short term knowledge day trader.
Low level programming, distributed systems, ML, networking, math, file system design, cryptography, computer vision, formal verification, technical writing, etc etc
all of those are good choices. Keep moving. Learning is never wasted.
Endlessly scrolling to figure out where the winds will blow tomorrow is a waste of time.
Success comes from preparation, not anticipation.
Decipher Club retweeted
the "tech bro" dilemma in 2026
what should I learn bro?
"Learn a programming language"
– which one bro
"Depends. What's your goal?"
– I wanna be AI-proof bro
"Then start with Python"
– Python is too easy bro. AI writes it better than me
"Then learn Rust"
– Rust is too hard bro. AI writes it anyway, what's the point
"If AI writes everything, learn how AI works"
– that needs math bro
"Learn math"
– shut d fck up bro
"Fine, skip the math. Just build AI agents"
– the framework I learned got deprecated last Tuesday bro
"Then learn the fundamentals. Those don't get deprecated"
– that takes 4 years bro
"That's literally what a CS degree is for"
– I have one bro. I learned Java applets
"Then do a master's"
– 2 more years and a loan bro
"Skip college. Take online courses"
– recorded three model releases ago, bro
"Learn by building projects then"
– what do I build bro, everything already exists
"Clone something that exists"
– I asked Claude to clone it. Done in 10 minutes. Learned nothing bro
"Contribute to open source"
– every good first issue gets claimed in 4 minutes bro
"Just grind LeetCode and get a job"
– Claude solves hards in 4 seconds bro
"Then why do interviews still ask LeetCode"
– because the interviewer grinded it in 2019 and wants revenge bro
"Aim higher. Learn system design"
– bro my app has 12 users
"Get more users. Learn marketing"
– I'm an engineer bro, I don't do marketing
"Build in public then"
– I have 43 followers and 38 of them are bots bro
"Join a startup, learn on the job"
– they want 3 years of experience for an intern role bro
"Then start your own startup"
– I don't have an idea bro
"Build an AI wrapper"
– OpenAI will ship it as a feature next week bro
"Build in crypto"
– crypto is dead bro
"Crypto isn't dead"
– my portfolio is bro
"So what are you learning right now?"
– watching a 3-hour video on what to learn bro
Decipher Club retweeted
Learning never goes in vain
software builders today r painfully anxious - wasting hours/weeks on “what to learn if AI can do it all”
“Learning” - the act in itself is a super valuable skill.
if for nothing else, learn how to learn efficiently, from first principles
Decipher Club retweeted
LI.FI is live on Robinhood Chain.
Robinhood Chain mainnet is live.
Fast, secure, AI-native, and purpose-built for real-world assets from day one.
xitter.cf/i/broadcasts/1YxNrrAME…
Decipher Club retweeted
SEDA computes price data.
Oracles transport price data.
Better markets start on better pricing logic.
seda.xyz/signal
Decipher Club retweeted
SEDA is Now Live for protocols on Robinhood Chain
Access custom oracle infrastructure powering 24/7 RWA Perps & Lending markets in one endpoint.
→ seda.xyz
Decipher Club retweeted
As a Smart Contract Engineer, Slap yourself if you cannot clearly explain at least 10 of the following:
1. EVM memory vs storage vs calldata layout
2. Storage slot packing & inheritance slot collisions
3. Transient storage (EIP-1153) use cases
4. delegatecall context preservation & storage layout traps
5. Proxy patterns: Transparent vs UUPS vs Beacon
6. Storage gaps in upgradeable contracts
7. Diamond pattern (EIP-2535) & facet selector clashes
8. Function selector collisions & 4-byte clashing attacks
9. ABI encoding vs encodePacked hash collisions
10. Checks-Effects-Interactions ordering
11. Reentrancy: single-function, cross-function, cross-contract, read-only
12. ERC-777 hooks & callback reentrancy surface
13. Gas griefing via return-bomb / unbounded returndata
14. 63/64 gas forwarding rule (EIP-150)
15. try/catch failure modes & bubbling reverts
16. Custom errors vs require strings gas trade-offs
17. SafeMath obsolescence & 0.8 overflow semantics
18. Unchecked blocks: when they're safe
19. Signed vs unsigned integer pitfalls in arithmetic
20. Fixed-point math & precision loss ordering
21. Front-running & sandwich attack mechanics
22. Commit-reveal schemes & MEV mitigation
23. Flashloan-based price oracle manipulation
24. TWAP oracles & manipulation cost analysis
25. EIP-712 typed structured signing
26. Signature malleability & ecrecover(0) handling
27. Replay protection across chains (chainId binding)
28. Permit (EIP-2612) & gasless approvals
29. Nonce management for meta-transactions
30. Account abstraction (EIP-4337) UserOp lifecycle
31. EIP-7702 set-code-for-EOA implications
32. CREATE vs CREATE2 address derivation
33. Metamorphic contracts & selfdestruct redeployment
34. selfdestruct post-Cancun (EIP-6780) semantics
35. Init-code vs runtime bytecode distinction
36. Immutable vs constant storage mechanics
37. Gas refund mechanics & SSTORE gas accounting (EIP-2929/3529)
38. Access list transactions (EIP-2930)
39. Warm vs cold storage access costs
40. Yul / inline assembly memory safety
41. Free memory pointer (0x40) discipline
42. Scratch space (0x00–0x3f) misuse
43. Bit manipulation & masking for packed structs
44. ERC-20 approve race condition
45. Fee-on-transfer & rebasing token integration breakage
46. ERC-721 safeTransfer reentrancy via onERC721Received
47. ERC-1155 batch transfer accounting
48. ERC-4626 vault inflation / donation attacks
49. First-depositor share-price manipulation
50. Rounding direction (round up vs down) in vault math
51. Pull-over-push payment patterns
52. Block.timestamp manipulation bounds
53. blockhash limitations & on-chain randomness fallacies
54. VRF integration & request-fulfill patterns
55. Merkle proof verification & second-preimage attacks
56. Bitmap-based airdrop claim tracking
57. Multicall & msg.value reuse across calls
58. Delegatecall to untrusted code
59. tx.origin phishing vector
60. Gas-efficient storage clearing for refunds
61. Packed storage write ordering for gas
62. Cross-contract call gas stipend assumptions
63. Forced ETH via selfdestruct breaking invariants
64. Initialization front-running on proxies
65. Signature replay across forks
66. L2 sequencer downtime oracle staleness
67. Optimistic rollup 7-day withdrawal mechanics
68. Blob transactions (EIP-4844) & calldata cost shifts
69. Precompiles (ecrecover, modexp, pairing checks)
70. BLS signature aggregation verification
71. Reentrancy guards vs transient storage locks
And if you only know 10 — kindly return the "Senior Smart Contract Engineer" title.
As a Backend Developer, Slap yourself if you cannot clearly explain at least 10 of the following:
TCP congestion control algorithms
TLS 1.3 handshake internals
HTTP/2 multiplexing & HPACK
HTTP/3 + QUIC packet loss recovery
Connection pooling pitfalls
Zero-downtime deployment strategies
Database transaction isolation levels (serializable vs snapshot)
B-tree vs LSM-tree index internals
Query planner & cost-based optimization
Deadlock detection & prevention
ACID vs BASE trade-offs
Two-phase commit vs Saga pattern
Distributed locking (Redlock pitfalls)
CAP theorem in practice
CRDTs & conflict-free replicated data types
Eventual consistency anti-patterns
Kafka partition rebalancing & exactly-once semantics
RabbitMQ dead-letter queues & message ordering
gRPC streaming + flow control
GraphQL resolver batching & N+1 problem
OAuth2 token introspection vs JWT validation
Rate limiting algorithms (token bucket vs leaky bucket)
Circuit breaker + bulkhead patterns
Observability: OpenTelemetry tracing propagation
Prometheus metric cardinality explosion
Log aggregation with sampling
Memory-mapped files vs traditional I/O
Garbage collection tuning (G1 vs ZGC)
Thread pools vs virtual threads (Project Loom)
Actor model vs shared-memory concurrency
Message-driven architecture (Akka / Orleans)
CQRS + Event Sourcing projections
Outbox pattern for reliable events
Sharding strategies & hot partition avoidance
Read replicas lag monitoring
Database connection pool exhaustion
Prepared statement caching
Index bloat & vacuum strategies
Kubernetes pod disruption budgets
Service mesh traffic shifting
Serverless cold-start mitigation
API gateway throttling & caching layers
Background job queues (Celery / BullMQ) retry semantics
Distributed cache invalidation (cache-aside vs write-through)
Eventual consistency in cache
Idempotency keys in API design
Optimistic locking with version vectors
Paxos / Raft consensus internals
Byzantine fault tolerance basics
Chaos engineering principles
Database failover & split-brain prevention
Microservices observability (distributed tracing)
API contract testing (Pact / Spring Cloud Contract)
Backward-compatible schema evolution
Protobuf vs JSON performance trade-offs
Binary protocol parsing
Zero-copy networking (sendfile)
epoll / kqueue internals
Syscall overhead & context switching
Memory barriers & CPU cache coherence
Lock-free data structures
Bloom filters & HyperLogLog in practice
Consistent hashing for load balancing
Virtual memory & page faults impact
Container runtime security (seccomp, AppArmor)
Sidecar pattern limitations
Service discovery (Consul vs DNS)
Blue-green vs canary deployments
Feature flags with rollout strategies
Data pipeline backpressure handling
Exactly-once processing guarantees
Idempotent consumers in event streams
And if you only know 10 — kindly return the “Senior Backend Developer” title. 😄
Decipher Club retweeted
use create-8004-TAP-agent to create new TAP agents or register/bind existing ones.
shoutout to @VittoStack for create-8004-agents scaffold CLI tool.
github.com/zaryab2000/create…
Decipher Club retweeted
ERC-8004 gave us Trustless Agents.
I built Trustless Agents Plus - TAP
A solution for fragmented multi-chain ERC8004 AI Agents.
With TAP, your multi-chain Agent acts like ONE.
One aggregated reputation.
One canonical identity.
On-chain verifiable.
Soulbound.
Try it out 👇
Decipher Club retweeted
Built Overhang — paste any token, get your safe size, whale PnL overhead, and a staged exit plan before you ape.
@birdeye_data #BirdeyeAPI #BuildInPublic




















