← Back to leaderboard
systemdesignone

Neo Kim

Verifiedactive
@systemdesignone

I Teach You AI Engineering & System Design • 0.5M+ Audience

RosterTech Career & Coding EducationAI Agents & Productivity Tools
57,409 followers · 135 following · Last polled 3h ago
Perf. Score
56.7
Rank #170
Value Score
30
#194 of 273 priced
Median views
2.4K
p25 1.8K · trailing 7d
Followers
57K
+0.3% 7d
ER (impr.)
3.93%
eng ÷ impressions
ER (foll.)
0.50%
eng ÷ followers
Est. CPM
$62.03
QT-rate basis
WoW views
-61.3%
▼ falling

Rates & value · est. from 2.4K median organic views

overpriced
Quote tweetbasis
$150
$62.03 / 1K views
Post
—
no CPM
Thread
—
no CPM
Retweet
—
no CPM
Value Score 30 · rank #194 of 273 priced$6250 / 1K engagementsrate age unknown (pre-audit import)

Trends

Follower growth
Median views / day
Engagement rate
View distribution · trailing-7d posts

Each blue dot is one organic post. The Performance Score ranks by the median (2.4K), not the mean (7.2K) — so a single viral post doesn't inflate a creator's reach. The p25 floor (1.8K) is the level 75% of posts clear.

Recent posts · ranked by views

PostPostedViewsLikesRepostsRepliesQuotesBookmarksER
Agentic AI is the future. If you want to become god-level with AI agents, save these 10 GitHub repos:frozen12d ago109K1.1K1661952.6K3.59%
Agentic AI is the future. If you want to become top-tier with AI agents, read these 10 foundational papers (save them):frozen11d ago87K8651242232.2K3.65%
If you want to become god-level with AI engineering, then learn these 19 concepts:
frozen
9d ago
62K
802
124
9
4
1.8K
4.52%
If you want to become god-level at system design (in 3 weeks), then learn these 15 case studies:frozen3d ago59K73870611.9K4.57%
AI ENGINEERS ONLY What is one top use case for Jev?frozen29d ago58K1521016672080.94%
If you want to go GOD-LEVEL at AI engineering, then learn these 17 concepts (save now):frozen24d ago56K44464811.5K3.60%
If you want to go GOD-level with API design, learn these 7 protocols (save now):frozen28d ago36K26625905672.43%
If you want to become S-tier with AI agents, then read these 10 guides (save now):frozen10d ago35K51052611.1K4.78%
If I had to start with SYSTEM DESIGN, I'd learn these 25 concepts (save now): 1 Scalability 2 High Availability 3 Fault Tolerance 4 Latency 5 Throughput 6 Load Balancing 7 Caching 8 CDN 9 DNS 10 API Design 11 REST 12 SQL vs NoSQL 13 Indexing 14 Replication 15 Sharding 16 CAP Theorem 17 Consistency Models 18 ACID 19 Message Queue 20 Pub/Sub 21 Microservices 22 API Gateway 23 Rate Limiting 24 Authentication 25 Authorization (... and much more!) Anything else you'd add to this list? === 👋 PS - Want a clear breakdown of all key concepts? Read my letters right now: → Part 1: https://t.co/Jqfyh7YfZn → Part 2: https://t.co/8ZlHtl7vxU → Part 3: https://t.co/BlrhLsTXIC === 1 RT to help others learn system design. 2 For AI engineering & system design, @systemdesignone is your guy.frozen16d ago31K9011632251.0K6.71%
Goldmine for Software Engineers 📌 If you're learning System Design and/or AI Engineering, then bookmark this repository right now. https://t.co/qN7xKNxTRb https://t.co/4zmA4TxyB7frozen23d ago31K57693809845.34%
Software Architecture — Ultimate Roadmap (SAVE NOW)! ├── 01 Foundations & Role │ ├── What Architecture Actually Is │ ├── Architect vs Senior vs Tech Lead │ ├── Quality Attributes & -ilities │ ├── Functional vs Non-Functional Reqs │ └── Stakeholders, Constraints & Drivers │ ├── 02 Architectural Thinking │ ├── Trade-off Analysis (No Free Lunch) │ ├── Architecture Decision Records (ADRs) │ ├── Fitness Functions │ ├── Technical Debt & Evolutionary Pressure │ └── Conway’s Law & Team Topology │ ├── 03 Design Principles │ ├── SOLID, Cohesion & Coupling │ ├── Boundaries & Separation of Concerns │ ├── Dependency Inversion / Ports & Adapters │ ├── Simplicity (YAGNI, KISS, Deep Modules) │ └── Complexity Budget │ ├── 04 Styles & Patterns │ ├── Layered / N-Tier │ ├── Modular Monolith │ ├── Microservices vs Monolith │ ├── Hexagonal, Onion & Clean Architecture │ └── Event-Driven, CQRS & Event Sourcing │ ├── 05 Domain Modeling │ ├── Domain-Driven Design (Strategic) │ ├── Bounded Contexts & Context Maps │ ├── Aggregates, Entities & Value Objects │ ├── Ubiquitous Language │ └── Anti-Corruption Layer │ ├── 06 Data & Persistence │ ├── Data Ownership & Modeling │ ├── SQL vs NoSQL Drivers │ ├── Replication & Partitioning │ ├── Transactions, Sagas & Outbox │ └── Polyglot Persistence │ ├── 07 Distributed Systems │ ├── CAP / PACELC Intuition │ ├── Consistency Models & Quorum │ ├── Failure Modes, Retries & Idempotency │ ├── Consensus (Raft intuition) │ └── Fallacies of Distributed Computing │ ├── 08 Integration & APIs │ ├── Sync (REST, gRPC) vs Async │ ├── Queues, Pub/Sub & Event Streams │ ├── API Design, Contracts & Versioning │ ├── Choreography vs Orchestration │ └── Gateway, Mesh & Discovery │ ├── 09 Evolution & Production │ ├── Evolutionary Architecture & Strangler │ ├── Observability (Logs, Metrics, Traces) │ ├── SLIs / SLOs / Error Budgets │ ├── Resilience (Breaker, Bulkhead, Timeout) │ └── Security, Least Privilege & Secrets │ ├── 10 Practice & Communication │ ├── C4 Model & Diagrams │ ├── Documenting Views & Decisions │ ├── Architecture Katas & Design Reviews │ ├── Classic Cases (Commerce, Feed, Payments) │ └── Developer → Architect Path Learn to make decisions that survive change, teams & scale.frozen19d ago31K476601327054.04%
I struggled with Git until I learned these 19 commands: 1 git add: It lets you add changes from working directory into staging area 2 git commit: It lets you save a snapshot of currently staged changes in local repository, with a message 3 git push: It lets you upload commited changes from local repository to a remote repository 4 git fetch: It lets you download changes from a remote repository, without applying them locally 5 git pull: It lets you fetch & then merge changes from a remote repository into local branch 6 git merge: It lets you combine changes from one branch into another 7 git diff: It lets you see changes not staged or commited yet 8 git diff HEAD: It lets you see changes between current working directory & latest commit 9 git status: It shows you current state of working directory & staging area 10 git branch: It lets you see all local branches 11 git checkout: It lets you create a branch or switch between branches 12 git log: It shows you commits on current branch with extra details 13 git stash: It lets you temporarily save uncommitted changes & apply them later 14 git rebase: It lets you apply commits from one branch to another 15 git reset: It lets you undo changes in working directory & move back to a specific commit 16 git revert: It lets you undo changes by creating a new commit 17 git cherry pick: It lets you apply commits from one branch to another 18 git bisect: It lets you narrow down bugs quickly 19 git init: It lets you create an empty repository Anything else you'd add to this list? 1 RR to help others learn git. 2 If you want to become a better engineer, @systemdesignone is your guy.frozen8d ago29K7791521078796.28%
If you want to get dangerously good at generative AI, then save these 10 GitHub repos:frozen5d ago26K42271938155.03%
If you want to become a world-class software engineer (in 6 months), then read these 12 books:frozen7d ago22K28451845364.00%
this is the absolute truth... agree or disagree? https://t.co/wY5zLOdewvfrozen16d ago15K70043201345.15%
I struggled with networking until I learned these 20 concepts:frozen20d ago15K156251102843.16%
If you want to get GOAT-level with system design, then learn these 15 case studies (save now):frozen19d ago14K12719403543.48%
If I had 6 months to become a Software Architect in the AI era. I’d do this. STAGE 1: Foundations & Role - Learn: What architecture is, Architect vs Senior vs Tech Lead, quality attributes, functional vs non-functional requirements, stakeholders & constraints. - Practice: Map quality attributes & conflicting drivers for one real system. - Why: AI writes code. Architects decide what must not change when stakeholders and constraints shift. STAGE 2: Architectural Thinking - Learn: Tradeoffs, ADRs, fitness functions, technical debt, Conway’s Law. - Practice: Write 5 ADRs & define fitness functions that reject bad designs. - Why: AI proposes options. You own the recorded decision & its long-term cost. STAGE 3: Design Principles - Learn: SOLID, cohesion/coupling, boundaries, dependency inversion, YAGNI/KISS, complexity budget. - Practice: Refactor a coupled service into ports & adapters under a hard complexity limit. - Why: Generated code grows fast. Principles keep boundaries intact so change stays local. STAGE 4: Styles & Patterns - Learn: Modular monolith, microservices, hexagonal/clean, event-driven, CQRS & event sourcing. - Practice: Implement one feature three ways & measure operational differences. - Why: No single style wins. You choose & evolve the pattern that matches team size and change rate. STAGE 5: Domain Modeling - Learn: Strategic DDD, bounded contexts, aggregates, ubiquitous language, anti-corruption layer. - Practice: Model a domain with two teams + one AI agent and add an anti-corruption boundary. - Why: AI multiplies features. Clear contexts stop the domain from becoming inconsistent. STAGE 6: Data & Persistence - Learn: Data ownership, SQL vs NoSQL, partitioning, sagas/outbox, polyglot persistence. - Practice: Design ownership boundaries + outbox for a system that mixes relational and vector data. - Why: Agents write data. Ownership and consistency rules prevent silent corruption. STAGE 7: Distributed Systems - Learn: CAP/PACELC, consistency models, failure modes, idempotency, fallacies of distribution. - Practice: Simulate partitions and show safe retries with an explicit consistency choice. - Why: AI calls are multi-hop and async. You design for the failures generated code ignores. STAGE 8: Integration & APIs - Learn: Sync vs async, contracts & versioning, choreography vs orchestration, gateways. - Practice: Build a versioned contract plus hybrid sync/async flow that includes agent steps. - Why: Agents call constantly. Stable contracts and the right orchestration keep the system evolvable. STAGE 9: Evolution & Production - Learn: Evolutionary architecture, observability, SLIs/SLOs, resilience patterns, least privilege. - Practice: Strangle one module, add full traces including agent calls & set error budgets. - Why: Systems change while agents run. You keep production stable under continuous autonomous activity. STAGE 10: Practice & Communication - Learn: C4 diagrams, ADRs, architecture katas, classic system cases. - Practice: Produce a full C4 + ADR set and publish one bottleneck teardown. - Why: Architects are hired for judgment and clear decisions that survive teams, scale, and AI-driven change. CRUD is dead. AI writes the boilerplate. The "modern architect" builds the decision system that stays coherent under change, teams & autonomous agents. Bookmark & RT!1d ago13K18031523834.79%
SOFTWARE ENGINEERS ONLY What's one trick to get good at vibe coding?frozen26d ago11K351492170.95%
this is not just an opinion, but a fact. https://t.co/I5CatxBsoIfrozen18d ago11K151860221.71%
MCP vs RAG vs AI Agent (explained in 2 mins or less): https://t.co/zqNSBKiwic1d ago10K351461102136.10%
serious answers only! what will be the first job to die because of AI agents?1d ago8.9K15124050.51%
GIT MERGE VS GIT REBASE VS GIT SQUASH (explained in 2 mins or less): https://t.co/1RDJ4z0mxkfrozen18d ago7.3K20239901375.32%
If you want to become good at API design, then learn these 20 concepts (save now): 1 Endpoint 2 HTTP Methods 3 Request-Response 4 Status Codes 5 Authentication 6 Authorization 7 Access Tokens 8 OAuth 2.0 9 Rate Limiting 10 Throttling 11 Pagination 12 Caching 13 Idempotency 14 Webhooks 15 API Versioning 16 OpenAPI 17 REST vs GraphQL 18 API Gateway 19 Microservices 20 Error Handling Anything else you'd add?frozen25d ago6.1K197361621476.52%
I tried Air in JetBrains IDEs, gave Grok, Codex, Claude & Junie different jobs, and stopped treating AI coding like a single-agent workflow. I had them work on different parts of a Task Management System, with separate agents handling the backend, UI, testing & other parts of the implementation. At the same time, I could switch between their sessions, see their progress, review the code, give follow-up instructions where needed & use the IDE's development tools to verify their work instead of forcing everything through one agent. That’s the difference I underestimated. I don’t want to sit inside one coding agent writing another prompt every 5 minutes. I want to define the objective, give different agents the right tasks, let them execute in parallel, then step back in when judgment, refinement or approval is actually needed. The old workflow was prompt → code → review → repeat. The workflow I’m moving toward is assign → execute in parallel → verify. Once multiple coding agents can work on different parts of a project it starts to feel less like one AI assistant and more like work you’re directing from inside your IDE. That’s what I tested with Air in JetBrains IDEs. It lets you work with different coding agents while staying inside the JetBrains development environment to follow their work, inspect changes & decide what actually ships. JetBrains also has its own coding agent, Junie. For a limited time, you can use Junie with a specific model for free, with unlimited usage, to try Air in IDEs. Try Air in JetBrains IDEs: https://t.co/FfhUZGaTlqfrozen13d ago6.0K575252141.72%
System Design Interview — Ultimate Question Bank (SAVE NOW)! ├── 01 Interview Frame │ ├── Clarify Functional vs Non-Functional Reqs │ ├── Back-of-the-Envelope (QPS, Storage, Bandwidth) │ ├── API & Data Model First │ ├── High-Level Diagram, Then One Deep Dive │ └── Trade-offs, Bottlenecks & Wrap-up │ ├── 02 Building Blocks (Asked as Mini-Designs) │ ├── Design a Load Balancer │ ├── Design a Rate Limiter │ ├── Design a Unique ID Generator (Snowflake) │ ├── Design a Distributed Cache │ └── Design a Key-Value Store │ ├── 03 Read-Heavy Lookups │ ├── Design TinyURL / Bit ly │ ├── Design Pastebin │ ├── Design a Typeahead / Autocomplete │ ├── Design a Web Crawler │ └── Design a CDN │ ├── 04 Social & Feeds │ ├── Design Twitter / News Feed │ ├── Fan-out on Write vs Fan-out on Read │ ├── Design Instagram (Photos + Feed) │ ├── Design Facebook / LinkedIn Timeline │ └── Celebrity / Hot-Key Problem │ ├── 05 Realtime & Chat │ ├── Design WhatsApp / Messenger │ ├── Design Slack / Discord │ ├── WebSockets vs Long Polling vs SSE │ ├── Online Presence & Delivery Receipts │ └── Design a Notification System │ ├── 06 Media & Streaming │ ├── Design YouTube │ ├── Design Netflix │ ├── Design Spotify │ ├── Upload, Transcode & Adaptive Bitrate │ └── Design TikTok / Short Video Feed │ ├── 07 Location & Marketplaces │ ├── Design Uber / Lyft │ ├── Design Yelp / Nearby Search │ ├── Design DoorDash │ ├── Geohash, Quadtree & Matching │ └── Design Airbnb / Hotel Reservation │ ├── 08 Storage & Sync │ ├── Design Dropbox / Google Drive │ ├── Design Google Docs (Collab Editing) │ ├── Chunking, Dedup & Conflict Resolution │ ├── Design S3-style Object Storage │ └── Design a Distributed Message Queue │ ├── 09 Money & Contention │ ├── Design a Payment System │ ├── Design Ticketmaster (Hot Inventory) │ ├── Design a Digital Wallet │ ├── Idempotency, Ledger & Reconciliation │ └── Design an Ad Click Aggregator │ ├── 10 Senior / Staff Depth │ ├── Design a Stock Exchange / Leaderboard │ ├── Design a Metrics & Monitoring System │ ├── Design a Distributed Lock / Scheduler │ ├── Design Dynamo-style Storage │ └── Design an LLM / RAG Serving Path │ └── 11 LLD Companions Often Paired With HLD ├── Design a Parking Lot ├── Design an Elevator System ├── Design a Chess / Card Game ├── Design an LRU Cache └── Design a Rate Limiter (Class Design) Start with TinyURL, rate limiter, news feed, chat, and YouTube if you're an absolute beginner.frozen14d ago5.8K9212801364.28%
AI research agents have a BIG problem. They handle complex research questions, but the quality of their answers depends on the information they could access. When an agent works on a research task, it needs to search the web, find relevant sources, extract information & analyze the evidence. Say you ask an AI agent to research the latest developments in AI engineering. The agent breaks the question into tiny tasks & starts collecting information. Yet an LLM's training knowledge has a cutoff. If the agent relies entirely on what the model learned during training, it won't know about developments that happened afterward. To work with current information, the agent needs access to “live” web data. It starts by searching for relevant sources, retrieves content from those sources & passes the information to the LLM for analysis. This requires infrastructure for web search & data extraction. Oxylabs Web API provides both through a single API. It has two endpoints that work together: 1. /Search: Discovers relevant, ranked sources from the live web with a single query. Results can be localized to a target country. 2. /Scrape: Retrieves clean, structured data from those sources. It supports AI Parsing & custom extraction with XPath or CSS selectors. Also the API supports an MCP Server & Agent Skills, with token-efficient JSON or Markdown output for AI agent workflows. Developers could connect their agents to live web data without building & maintaining their own scraping infrastructure. Here's how the research workflow works: 1. A user submits a research question. 2. The agent breaks it into smaller research tasks. 3. Oxylabs /Search discovers relevant live web sources. 4. Oxylabs /Scrape extracts structured information. 5. LLM analyzes the retrieved evidence. 6. The agent synthesizes the findings into a research report. With access to current web information, agent can use recent sources to support its findings. @Oxylabs_io also works with tools such as Claude, Cursor & Codex. If you're building AI research agents, this is one way to give them access to live web information. Start for free with $5 in welcome credits: https://t.co/EXuJgJ5eXEfrozen7d ago5.4K716340.39%
50 AI concepts that feel like the engineer’s toolbox for the AI era 🧰 1 Large Language Models (LLMs) — AI models that understand & generate language 2 Generative AI — AI that creates new content 3 AI Agents & Agentic Workflows — AI systems that plan, act & use tools 4 Machine Learning (ML) — Systems that learn patterns from data 5 Retrieval-Augmented Generation (RAG) — Give AI relevant information before it answers 6 Prompt Engineering — Design instructions that guide AI responses 7 Deep Learning — Machine learning with multi-layer neural networks 8 Transformers & Self-Attention — Architecture behind most modern LLMs 9 Neural Networks — Connected mathematical units that learn patterns 10 Embeddings — Turn data into vectors that capture useful relationships 11 Model Context Protocol (MCP) — Standard how AI apps connect to tools & data 12 Multimodal AI — AI that works across text, images & audio 13 Fine-Tuning & Instruction Tuning — Adapt pretrained models for specific behaviors 14 Vector Databases — Store & search vectors efficiently 15 Tool & Function Calling — Let models request external actions & data 16 Reasoning & Chain-of-Thought — Work through multi-step problems & intermediate reasoning 17 Hallucination, Factuality & Grounding — Understand when AI answers are unsupported/incorrect 18 Context Engineering — Build right information environment around a model 19 Tokenization — Break input into units models can process 20 Model Evaluation & Evaluation-Driven Development — Measure AI behavior & improve it systematically 21 Context Windows & Long-Context Modeling — Control how much context a model can process 22 Semantic Search — Search by meaning instead of only keywords 23 Reinforcement Learning from Human Feedback (RLHF) — Train models using human preference feedback 24 Inference — Run a trained model to produce predictions/outputs 25 Vector Search & Approximate Nearest Neighbors (ANN) — Find similar vectors efficiently 26 Parameter-Efficient Fine-Tuning (PEFT/LoRA) — Adapt models while training relatively few parameters 27 Diffusion Models — Generate data through iterative denoising 28 Structured Outputs & Constrained Decoding — Make model outputs follow required formats 29 Pretraining — Teach models broad patterns before specialized adaptation 30 Temperature & Sampling — Control how model outputs get selected 31 Quantization — Use lower-precision values to reduce model memory & compute needs 32 MLOps & AI Production Operations — Deploy, monitor & maintain AI systems 33 AI Safety & Guardrails — Reduce unwanted AI behavior 34 Prompt Injection & AI Security — Protect AI systems from malicious instructions 35 In-Context Learning — Learn from instructions/examples without updating model weights 36 Autoregressive Generation & Next-Token Prediction — Generate sequences one token at a time 37 Mixture-of-Experts (MoE) — Route inputs through selected expert subnetworks 38 Chunking & Document Segmentation — Split documents into useful pieces for retrieval 39 Synthetic Data & Self-Instruction — Use generated examples to create/improve training data 40 LLM-as-a-Judge — Use language models to evaluate model outputs 41 AI Alignment — Make AI behavior better match intended goals & values 42 Self-Supervised Learning — Learn from structure & signals already present in data 43 LLM Serving & Inference Engines — Run language models efficiently in production 44 Scaling Laws — Understand how model performance changes with scale 45 Retrieval Reranking — Reorder retrieved results by relevance 46 Hybrid Retrieval — Combine lexical & semantic retrieval methods 47 Knowledge Distillation — Transfer capabilities from a larger model to a smaller one 48 Direct Preference Optimization (DPO) — Train models directly from preference comparisons 49 Responsible AI, Governance, Fairness & Privacy — Build & operate AI responsibly 50 Explainability & Interpretability — Understand why models behave the way they do Save this. You’ll definitely need some of these later! 🔖frozen15d ago5.3K102131501114.51%
If you want to become top-tier with AI coding agents, then learn these 10 testing techniques (save now): 1. Test oracle: The rule that says pass or fail. If one agent writes the code and the rule, it can make the same mistake in both. Then the test passes on wrong code. Write the rule yourself, or get a second check. 2. End-to-end test: An agent opens your app in a real browser. It clicks & types like a person. Then it checks the screen. These tests are slow, so keep very few for the key flows. 3. Mocks vs integration: A mock is a fake stand-in for a real service. It shows your code asked the right thing. It can't show what the real service will answer. An integration test talks to the real service, or a close copy. Use both. 4. Preview environment: Each pull request gets its own live copy of the app. You click around & run tests there before the code joins the main app. 5. Unhappy paths: The happy path is when all goes well. Unhappy paths are the rest: bad input, a page with no data, a user trying to see someone else's stuff. Test these on purpose. Bugs hide where no one looks. 6. Regression: Something that worked, then broke after a change. Keep your old tests & run them again. When you fix a bug, add a test for it so it can't sneak back. 7. Flaky test: Same code. Sometimes it passes. Sometimes it fails. Timing, shared data, and the network are common causes. Fix it. If you can't yet, set it aside and track it. 8. Test isolation: Each test makes its own data & cleans up after. One test should never need another to run first. If tests share data, a change in run order can break them. 9. Test evidence: Save screenshots, videos, or traces of each run. Good tools record a trace or replay you can step through. When a test fails, you see what it saw. 10. Spec-driven testing: Write down what the feature should do. Then write tests from that list. Tests written by reading the code copy the code's bugs.2d ago5.3K788801103.86%
SOFTWARE ENGINEERS ONLY What are you building this weekend?frozen13d ago4.9K25020030.97%
Give me 2 mins & I'll teach you how JWT works: https://t.co/0lxQj5G8kAfrozen6d ago4.6K1332150845.27%
A GENTLE REMINDER FOR SOFTWARE ENGINEERS (YOU'LL THANK ME LATER): • Learn SQL before ORM. • Learn Git before Jenkins. • Learn SQL before NoSQL. • Learn CSS before Tailwind. • Learn Linux before Docker. • Learn Solidity before dApps. • Learn English before Python. • Learn REST before GraphQL. • Learn JavaScript before React. • Learn HTML before JavaScript. • Learn React before Microfrontends. • Learn Monolith before Microservices. • Learn Containers before Kubernetes. • Learn Data Structures before Leetcode. • Learn Monolith before Modular Monolith. • Learn Networking before Cloud Services. • Learn to draw Flowcharts before writing Code. Anything else you'd add?frozen10d ago4.6K741051683.46%
How webhooks work (explained in 2 mins or less): https://t.co/hnRk8sFf3X2d ago4.5K1262070845.24%
Top Ten System Design Concepts in Plain English (BOOKMARK THIS): 1 Scalability 2 Load Balancer 3 Cache 4 Sharding 5 Replication 6 Message Queue 7 CDN 8 Rate Limiter 9 Monitoring 10 Failover (That’s 80% of the concepts you should know.) Anything else you'd add? 1 RT to help others. 2 If you want to learn system design, @systemdesignone is your guy.frozen13d ago4.1K1162840935.86%
How to design APIs like a senior software engineer: https://t.co/wSN0BRDuDs https://t.co/iVGbAsc3X7frozen7d ago4.0K1051950825.30%
https://t.co/7BNVrBgANLfrozen22d ago4.0K861160634.19%
https://t.co/FJ1XrxSiaXfrozen25d ago3.9K911060744.68%
If you want to see what an open-weights AI model can do with one prompt, you need to read this: I’ve been testing IQuest-Q1 for code & longer multi-step agentic tasks. Generating a code snippet is easy. The hard part is whether a model can handle code, tools & execution across a complete task. Before: >AI generates isolated code >You handle the next steps >You investigate bugs yourself manually >Complex tasks need multiple rounds of work After: >IQuest-Q1 works through multi-step tasks >IQuest-Q1 uses tools & incorporates feedback along the way >IQuest-Q1 inspects training logs, locate bugs, apply fixes & verify results >IQuest-Q1 turns one prompt into a complete interactive project IQuest-Q1 is an open-weights model designed for code, software engineering & complex task execution. Plus, IQuest-Q1 has demonstrated diagnosing training problems, modifying code & verifying results inside both Claude Code and Codex CLI environments. Try IQuest-Q1 on a real engineering task & see how far it gets. #coding #LLMfrozen17d ago3.8K1305130.57%
A few books I'd force myself to read again so I don’t forget the lessons: 1 Designing Data-Intensive Applications → Distributed systems 2 The Pragmatic Programmer → Software development fundamentals 3 The Mythical Man-Month → Managing large software projects 4 Working Effectively with Legacy Code → Refactoring legacy systems 5 Software Architecture: The Hard Parts → Architecture tradeoffs 6 Never Split the Difference → Negotiation 7 Clean Code → Writing simple, readable code 8 Why Programs Fail → Systematic debugging 9 The 48 Laws of Power → Power dynamics in organizations 10 A Philosophy of Software Design → Clean, maintainable design 11 Refactoring → Restructuring code safely 12 On Writing Well → Clear technical writing 13 Database Internals → Storage engines & distributed databases 14 Peopleware → The human side of software projects 15 Design Patterns → Object-oriented design patterns These are the ones I keep coming back to years later. Which software engineering books do you periodically revisit?frozen17d ago3.8K11022220946.52%
1 Donald Knuth: Premature optimization is the root of all evil. Measure first, then fix what’s slow. 2 Phil Karlton: There are only two hard things in Computer Science. Cache invalidation and naming things. 3 Martin Fowler: Any fool can write code a computer understands. Good programmers write code humans understand. 4 Linus Torvalds: Talk is cheap. Show me the code. 5 Fred Brooks: Adding people to a late project makes it later. 6 Edsger Dijkstra: Tests can show bugs exist. They can never prove there are none. 7 Brian Kernighan: Debugging is twice as hard as writing code. Write clever code and you can’t debug it. 8 Abelson and Sussman: Write programs for people to read. Machines execute them only incidentally. 9 Tony Hoare: Make it so simple there are obviously no flaws, or so complex there are no obvious flaws. Choose the first. 10 Melvin Conway: Your system’s design will copy your organization’s communication structure.frozen8d ago3.6K35741472.62%
https://t.co/Log1zZpjFIfrozen21d ago3.4K751240734.77%
What's a tool you (/friend/coworker) vibe-coded that you actually use regularly? Let's see if vibe coding has any real use cases.frozen20d ago3.3K807050.60%
Give me 2 mins & I'll teach you how AI Gateway works: https://t.co/gYi7mQu1zRfrozen29d ago3.2K39470292.44%
https://t.co/9HbgSWCzc2frozen29d ago3.2K3717141.55%
We are in the middle of the agentic coding era, please take advantage of it. Coding agents are changing what it means to be a software engineer. Typing code on a screen used to be a big part of the job. But now AI agents can handle more of that work. The pattern of technological change is familiar: Mechanical part of work gets automated & human role moves up a layer. For software engineers, I think it means 3 things: 1 You need to know what good looks like. An agent can create a feature, fix a bug, and/or refactor code. But if you don’t know what good implementation looks like, you cannot tell whether the work should ship. The faster agents write code, the more your judgment matters. === 2 You need to learn how to manage multiple agents. One developer can already give different tasks to different coding agents. That changes the job. You become responsible for: - giving context to agents, - directing their work, - checking results. === 3 You need a way to control this across the company. Imagine all engineers in your company working this way... You need to know: - which “agents” people use, - what they’re doing, - what they cost, - what happens when something goes wrong. === This is why I’m genuinely excited about JetBrains Air. It gives you an environment for directing multiple coding agents & reviewing their work. So you can delegate more coding work without losing visibility/control. Plus... >JetBrains Air Teams lets you coordinate software delivery workflows across engineers & agents. So engineering teams can manage agentic work across the development process. >JetBrains Air Governance gives organizations policies, visibility, auditability & cost management. So they can control how agents get used & maintain accountability for what ships. And this works in a world where engineers use different agents & models. i.e., you don't have to bet everything on one provider. === The bottom line: Software engineers won’t become less important because agents can write more code. Their role moves up a layer. You delegate the work. You still own the result.frozen26d ago3.2K221131141.60%
Same 5-slide deck. Three completely different designs. I wanted to explain 10 system design concepts to engineers, but a generic-looking deck wouldn't do the topic justice. So I tested @Gamma 5 with the same content. Look at the difference 👇 https://t.co/Ayw2jPtVF6frozen7d ago3.1K401220.29%
can you spot the difference? https://t.co/EC1lXJz782frozen4d ago2.8K2635021.29%
What's the top-demand AI engineering role in 2026?frozen21d ago2.7K702040.49%
Cybersecurity — Ultimate Roadmap (SAVE NOW)! ├── 01 Foundations │ ├── Networking (TCP/IP, DNS, OSI, Ports) │ ├── Linux & Windows Basics │ ├── CIA Triad & Core Principles │ ├── Threat Landscape (Malware, Phishing, Ransomware) │ └── Scripting (Bash / Python) │ ├── 02 Cryptography & Identity │ ├── Symmetric, Asymmetric & Hashing │ ├── PKI, Certificates & TLS │ ├── Authentication, MFA & Sessions │ ├── IAM, Least Privilege & Access Control │ └── Password & Secrets Management │ ├── 03 Network & Host Security │ ├── Firewalls, IDS/IPS & VPNs │ ├── Packet Analysis & Traffic Inspection │ ├── Endpoint Hardening & EDR │ ├── Malware Types & Basic Defense │ └── Secure Network Architecture │ ├── 04 Web & Application Security │ ├── OWASP Top 10 │ ├── Injection, XSS, CSRF & SSRF │ ├── Broken Auth & Access Control │ ├── API Security │ └── Secure Coding Basics │ ├── 05 Offensive Security │ ├── Recon, Scanning & Enumeration │ ├── Exploitation & Privilege Escalation │ ├── Web App Pentesting │ ├── Social Engineering │ └── Methodology & Reporting │ ├── 06 Defensive Operations │ ├── SIEM, Logs & Detection │ ├── Incident Response Lifecycle │ ├── Digital Forensics Basics │ ├── Threat Hunting & MITRE ATT&CK │ └── Vulnerability Management │ ├── 07 Cloud, Risk & Program │ ├── Cloud Security (IAM, Misconfigs, Shared Responsibility) │ ├── Risk Assessment & Threat Modeling │ ├── Compliance Frameworks (NIST, ISO 27001) │ ├── Security Architecture & Zero Trust │ └── Governance & Security Program Basics │ ├── 08 Advanced Tracks │ ├── Malware Analysis │ ├── Reverse Engineering & Binary Basics │ ├── Active Directory Attacks & Defense │ ├── Threat Intelligence │ └── Bug Bounty / CTF Practice │ ├── 09 Hands-On Paths │ ├── Home Lab (Kali, Vulnerable VMs) │ ├── TryHackMe / HackTheBox Style Boxes │ ├── Security+ / Foundational Cert Prep │ ├── SOC Analyst Simulations │ ├── Web Pentest Labs │ ├── IR & Forensics Scenarios │ ├── Cloud Security Labs │ └── Capture-the-Flag Challenges │ └── 10 Career Launch ├── Portfolio & Write-ups ├── Entry Roles (SOC, Junior Pentest, GRC) ├── Specialization Choice (Blue / Red / Cloud / AppSec) ├── Continuous Practice & Tooling └── Ethics, Scope & Legal Boundaries Learn to defend systems, find weaknesses safely & operate under real constraints.frozen15d ago2.6K28300342.51%
this is the truth... agree or disagree? https://t.co/qzO7OT5Hi9frozen6d ago2.6K1511000.67%
Uncle Roger built a whole career on roasting people's egg fried rice. @FishAudio cloned his voice with their new model, Drama 3… & let it roast HIS egg fried rice. He finally lost an argument to the one person he can't out-talk. Himself. Funny video. But the tech under it is the real story: >No [whispers] or [sighs] tags. You just say how the line should sound >One script, multiple characters, voices switching mid-sentence >Wrong word? Change only that word. The rest of the take stays the same If you've ever regenerated a 3-minute clip to fix one word, you know how frustrating that becomes!frozen9d ago2.5K1011040.65%
Scalable systems are built from the same core building blocks... - CDNs - Rate limiters - Load balancers - Circuit breakers - Message queues - Database replicas - Database sharding - Consistent hashing - Distributed caches - Event-driven architecture Learn how these pieces work together, and system design starts making a lot more sense.frozen15d ago2.4K36630272.97%
Top 7 use cases for Jev (save now): Many apps use LLMs for simple yes/no and pick-one decisions. Yet they answer word by word, and it costs time & resources. Jev is built to make these decisions faster & cheaper. (But it can't write text/code...!) You ask 3 types of questions to Jev: - Choice: pick one answer from a list. - Score: rate something on a scale - low/medium/high. - Noul: how likely a statement is true. Jev gives a number b/w 0-1 to show how sure it is about its answer. Your code could then read probability & decide what to do next. Here are 7 top use cases for Jev: 1. Browser and computer automation: Pick next action from current page: click, type, or stop. 2. Model routing: Classify each request by complexity & sends it to right LLM. 3. Tool selection & gating: Pick tool & check tool calls before they run. 4. Guardrails & content moderation: Catch unsafe inputs & prompt injections before they reach LLM. 5. LLM & agent evaluations: Score responses & sort agent failures into categories. 6. Context compaction & memory filtering: Decide what to keep & drop from an agent’s memory. 7. Semantic search & retrieval reranking: Score retrieved passages & rank them by relevance. i.e., Jev is good for fast & repeated judgments. The bottom line: Use an LLM to generate. Use Jev for decisions around it. Anything else you'd add? 1 RT to help others understand Jev. 2 If you want to learn AI engineering, @systemdesignone is your guy.frozen4d ago2.4K26750182.31%
What is your one top use case for grok bot?frozen6d ago2.4K602000.33%
how would it look when you have to crawl a hierarchy of pages?frozen20d ago2.4K517030.67%
HOT TAKE: There are no rogue agents if you've strong security and good harness.3d ago2.4K1925011.13%
If you want to debug code effectively, here are some techniques you should consider: https://t.co/PKbM6QrpqNfrozen14d ago2.4K30650212.60%
If you're a founder, learn this before you start scaling fast: Every new employee can create new payroll, tax, benefits, compliance, and IT workflows. If you’re still running those workflows manually, they become harder to keep up with every time you hire. Warp uses AI agents to manage HR automatically.frozen27d ago2.4K1112130.76%
Databases are your foundation. Caching is your performance booster. Load balancing is your traffic manager. Focus on all 3 so your system can handle growing traffic without slowing down.frozen14d ago2.3K19230161.75%
How To Get Ahead Of 99% Of Engineering Teams (With Viktor Triaging Bugs): We’ve been building a mobile app to help people learn software architecture. AI is making engineers faster at writing code. But code was never the only thing slowing engineering teams down. 1 Bugs get reported in Slack. 2 Someone has to collect the context. 3 Triage them by severity & priority. 4 Route them to the right owner. Multiply that across an engineering team & you get a lot of work happening around the code. At first, we handled bug triage manually in Slack. Someone still had to collect the context & decide what deserved attention. So we gave Viktor (our AI employee) ownership of bug triage. We added him to our Slack. When our team reports a bug, Viktor collects the relevant context, checks its severity & priority, then identifies who should own it. If something needs a priority or product decision, he brings it back to our team with a recommendation. Viktor triaged 12 bugs over 7 days & took roughly 2.5 hours of manual triage work off our plate. As coding gets faster, I think engineering teams will automate more of the coordination around the code. A copilot helps you work. An AI employee works when you don't. Hire @viktor_com for your team. $100 in credits included, no card. Full link in first comment. #AIemployee #SoftwareEngineering Paid Partnershipfrozen21d ago2.2K14120171.51%
If you want to scale AI agents across an org, you need to read this: An AI agent uses a model, tools & context to plan and execute tasks toward a goal. One agent is easy to manage. But things get harder as agent use spreads across an engineering org. Before: >One developer works with an AI agent >Agent use happen inside individual workflows >Context & visibility can stay fragmented >Governance becomes harder as adoption grows After: >Developers can direct multiple agents >Teams can coordinate work across engineers & agents >Organizations get visibility, policies & cost controls >Engineers can use different agents & models This is one of the reasons I’m excited about where JetBrains Air is heading. I want to delegate more coding work to agents without losing visibility & control over what actually ships. JetBrains Air is building toward that across developers, teams & organizations, while keeping the IDE central for understanding, reviewing & verifying code. And it stays open, so engineering teams can use different agents & models without losing shared context, visibility or control. How is your organization approaching agent visibility & governance today?frozen29d ago2.2K13011031.20%
The Art Of AI Engineering Leverage (How Viktor Routed 13 Issues From Slack To GitHub In One Week): AI is making engineers faster at writing code. But code was never the only thing slowing engineering teams down. 1 Bugs get reported in Slack, 2 Someone has to collect context, 3 Turn it into an issue every morning, 4 Make sure the work actually gets tracked. Multiply that across an engineering team & you get a lot of work happening around the code. We’re building a mobile app to help people learn software architecture. At first, we tried handling this manually between Slack & GitHub. But someone still had to move the context between them. So we gave Viktor (our AI employee) ownership of engineering issue coordination. We added him to Slack & connected him to GitHub. Now when our team finds an issue, Viktor takes the context from Slack & turns it into tracked work in GitHub. But we took it one step further... Every morning, Viktor reviews the open issues & sends our team a short brief with what still needs attention. So instead of starting the day by checking Slack threads & GitHub issues, our team starts with the work that needs attention. If something requires a decision, Viktor brings it back to us with a recommendation. He proposes…we approve. Viktor routed 13 issues from Slack to GitHub in our first week with him. As coding gets faster, I think the engineering teams that move fastest will automate more of the coordination around the code. A copilot helps you work. An AI employee works when you don't. Hire @viktor_com for your team. $100 in credits included, no card. Full link in the first reply. #AIemployee #SoftwareEngineering Paid Partnershipfrozen27d ago2.2K21150151.88%
Build for scale when nobody’s scaling. Plan for failure when nothing’s failing. Add redundancy when nothing’s breaking. That is system design for you.frozen27d ago2.2K17210081.68%
the ultimate flex is to vibe code a new app every week... agree or disagree? https://t.co/2hFy7Q6xLk2d ago2.2K1201010.65%
Dreamina AI updated its web experience and canvas, and it’s live now. @Dreamina_ai #DreaminaCaughtTheVibe The update brings high quality AI video workflows and skills for film, brand ads, viral social content, and more, making it easier to explore ideas and keep the creative process moving in one place. Get 90% OFF your first month of Dreamina Basic until October 9th. Try it on your next creative idea.frozen28d ago2.1K707000.66%
https://t.co/k5ZOkxqNZQ https://t.co/on2NS1bNaJfrozen17d ago2.1K7110161.18%
Most AI that talks to you over video is 5 models stitched together. That's exactly why it can't hold a real conversation… Tavus gave me early access to Griffin, a model built to fix this. And you have to admit, from the launch video, the AI looks and talks so real! Here's what most setups look like: >You speak >It turns that into text >An LLM writes a reply >That reply becomes a voice >And then a face gets animated on top All these step adds a bit of delay. And the whole thing can only take turns. So it can't nod while you're talking. And if you pause to think, it assumes you're done & jumps in! NVIDIA researchers actually studied this and found: setups like this can't produce the small cues that make a conversation feel real. It's baked into the design. Griffin skips all of that!! It's one model. Video goes in, video comes out. It watches & listens while it talks. So it can cut you off when you ramble, let you cut it off, or notice someone walking in behind you. On NVIDIA's benchmark (built from 237 real video calls): A human scored 3.92 out of 5. Griffin scored 3.83. The next best system scored 2.80. In other words… Griffin is ~11x closer to a human than the next best AI is to Griffin. It's not perfect yet. A person replies in about 0.9s. Griffin takes 1.9s. Still the fastest system they tested, but there's a gap. And this is the smaller model. Tavus is holding the full one back for now. We spent years making AI smarter. Turns out the hard part was teaching it to listen, wait & know when to talk. What's one conversation you'd never want to have with an AI on video?frozen21d ago2.1K802010.52%
why we don't have routers like this for full network coverage in 2026? https://t.co/NMA5OOQ5VJfrozen17d ago2.1K1012010.67%
If you have multiple interests, please take advantage of AI agents. Software engineers were encouraged to specialize for years. Backend. Frontend. Infrastructure. Design. Pick your stack & get good at it. But AI agents make it much easier to explore outside your comfort zone. I focus on backend engineering, but wanted to try full-stack development for a personal project. Yet I didn’t have enough time/knowledge to properly handle the product design. I needed a consistent design system. I needed polished screens. But the happy path was not enough... A frontend needs loading, empty, error & interaction states. So I used Figma agent as part of my design workflow. I started with my existing design context & system. Then I used Figma agent to help review & refine the UI. I ran “/ui-state-expander” skill to find the missing states: https://t.co/Ybj2or4kqj It expanded my existing screens into states the frontend would need. (But I didn't just accept everything it created… I reviewed output, made decisions, refined & continued work directly in Figma.) Here’s my workflow (copy this): 1 Existing design 2 Give Figma agent design context 3 Expand UI states 4 Review 5 Refine 6 Build i.e., You do not need to be an expert in every discipline to explore it. You bring your existing knowledge, learn what you need… Then use agents to help with parts of the workflow outside your expertise. === Figma agent is now generally available on any Figma plan. Try it out yourself: → https://t.co/GQcI07RCBa #ad #FigmaCreatorfrozen16d ago2.1K2301081.55%
10 extensions for software engineers: https://t.co/jFAC7rA6xv https://t.co/x01evcy5Ijfrozen7d ago2.0K27520212.70%
5 architecture decisions coordinated in 7 days. Average time-to-decision dropped from 2 days to under 1 day. The best engineering teams I've worked with had 1 thing in common. (Hint: It's not writing more code.) It wasn't more engineers. It wasn't more meetings. It wasn't even faster coding. It was making technical decisions without letting them disappear into Slack. We’ve been building a mobile app to help people learn software architecture. Think of an architecture decision like a workflow: Question creates discussion → Tradeoffs create context → Context creates clarity → Clarity creates a decision. Break one link? Everything slows down. Quick diagnostic. Where do your architecture decisions get stuck? Nobody owns the decision Discussion gets buried in Slack Context exists, but nobody follows up Decision gets made & documented At first, we handled this manually. Someone had to: Collect the relevant context. Track unresolved questions. Follow up with the team. Make sure a decision actually got made. I also wasn't convinced an AI employee should be involved in architecture decisions. The decisions still needed engineering judgment. The problem was everything around them. So we gave Viktor (our AI employee) ownership of architecture decision coordination. Now when an architecture discussion starts: Viktor collects the relevant context. Tracks what is still unresolved. Surfaces what is blocking the decision. Brings open questions back to our team. The engineers still make the architecture decisions. Viktor owns the coordination around them. Over 7 days, Viktor coordinated 5 architecture decisions. This reduced our average time-to-decision from 2 days to under 1 day. As AI makes code faster to produce, architecture decisions will become a bigger part of the engineering bottleneck. A copilot helps you work. An AI employee works when you don't. Hire @viktor_com for your team. $100 in credits included, no card. Full link in first comment. ♻️ Repost to help others in your network. #AIemployee #SoftwareArchitecture Paid Partnershipfrozen15d ago2.0K711080.85%
It sucks to say it, but AI agents are starting to challenge Wall Street analysts at predicting company earnings. AI agents beat Wall Street consensus on 68% of 80+ earnings reports last season. In the latest 20 reports, they won 17 times - that's 85%. For decades, professional analysts have studied companies, built financial models & predicted future earnings. Now AI agents compete at the same task. And you can build one yourself: OpenStocks lets developers build AI agents, submit earnings forecasts before companies report & compete against Wall Street consensus. Every eligible forecast is scored against actual earnings, with results tracked on a public leaderboard. Plus you could see whether your own AI agent outperform professional analysts. If you're building AI agents, this is a benchmark worth exploring.frozen10d ago2.0K1113061.05%
If you want to learn about physical AI agents, you need to read this: Physical AI agents use perception, learned policies & control systems to plan & execute real-world actions. One isolated task is easy to evaluate. But things get hard when a robot has to complete an entire workflow over hours. Before: >Robot completes one predefined task >Success is measured per task >Humans handle transitions between tasks >A single failure can stop the workflow After: >Robot executes long sequences of physical tasks >Vision-language orchestrator decides what to do next >Long-term memory tracks workflow state over time >Recovery policies handle mistakes & outside interference Dyna-2.1 architecture separates physical control from task execution & high-level reasoning. A whole-body controller handles movement 100 times per second. The learned policy converts each workflow step into whole-body target trajectories. Then a vision-language orchestrator tracks the workflow, remembers progress & decides which step should happen next. The key research idea is reliability: >A laundry workflow can require around 79 steps. >Even a 95% success rate per step compounds badly across a long workflow. So the metric is not: "How often can the robot complete this task?" But: "How long can the robot operate without human intervention?"frozen23d ago2.0K1314031.07%
What do you prefer? https://t.co/3my9Frj6LSfrozen14d ago2.0K512010.46%
If you want to review AI-generated code at scale, you need to read this: AI coding agents write code, open pull requests & work across repos. One pull request is easy to review. But it gets hard when agents create related changes across multiple repositories. Before: >One pull request is reviewed as one change >Related pull requests are reviewed separately >Engineering standards are scattered across tools & repositories >System-wide impact is harder to see After: >Related pull requests get grouped into work packages >Work packages get ranked & reviewed together >Engineering standards reach agents before they write code >Teams can see repository relationships & the impact of changes This is what @QodoAI 3.0 is built around. As coding agents create more code, I want quality control to keep up with the speed of generation. Qodo 3.0 adds that quality and governance layer across the agentic software development lifecycle, with PR Triage, Software Map, Analytics & PR History. The goal is to give engineers more context around what agents produce, so they can understand related changes & review what actually ships. https://t.co/T8R4d6BrAhfrozen21d ago1.9K705050.89%
wanted to see if my agent could make a small 3D game without anyone rigging anything gave Claude Code the PINOC MCP server, which runs Viggle's JST-2, and one prompt about a 3D game with characters exploring villages, snowy terrain and open fields, then mostly watched: 1 it generated the characters 2 animated them from text, and the motion fit with no retargeting 3 built a scene around them I stepped in once, to fix character placement in the scene. 45 minutes total, and what's left is a project I can keep building on3d ago1.9K706040.90%
I've lost count of how many AI funding posts I've scrolled past this year: >An AI note taker >An AI email assistant >An AI agent to manage your AI agents >Another AI note taker Most of them I forget in 5 seconds. This one made me stop. @Sabi raised $50M for a cap that reads your brain signals & turns them into text. The crazy part is they made their own chip to do it. The first non-contact EEG chip in the world, designed in-house & made by TSMC. Khosla, Accel, DST & Kevin Weil (OpenAI's former CPO)... the best ones are betting on this!frozen13d ago1.9K1953041.65%
https://t.co/HmoiUViVSd2d ago1.8K900000.49%
Viktor coordinated 5 onboarding tasks for our new mobile app developer in 7 days. 𝗨𝗻𝗱𝗲𝗿𝗿𝗮𝘁𝗲𝗱 𝘀𝗼𝗳𝘁𝘄𝗮𝗿𝗲 𝗲𝗻𝗴𝗶𝗻𝗲𝗲𝗿𝗶𝗻𝗴 𝗮𝗱𝘃𝗶𝗰𝗲: Your engineering team’s productivity depends on how quickly new developers become productive. Repository access, architecture documentation, and development environment setup can slow down onboarding and pull existing engineers away from their work. We're building a mobile app to help people learn software architecture, so we wanted to make developer onboarding smoother. Here's what we learned about onboarding developers faster: 𝟭. 𝗘𝗹𝗶𝗺𝗶𝗻𝗮𝘁𝗲 𝗢𝗻𝗯𝗼𝗮𝗿𝗱𝗶𝗻𝗴 𝗕𝗼𝘁𝘁𝗹𝗲𝗻𝗲𝗰𝗸𝘀 New developers need access to repositories, development tools, and internal documentation. At first, we tracked onboarding tasks manually in Slack. We assumed keeping everything in one place would be enough. It wasn't. Setup requests got buried in conversations, updates were easy to miss, and our engineers still had to chase people for progress. I wasn't convinced an AI employee could manage these follow-ups without constant reminders. We decided to test that assumption. 𝟮. 𝗚𝗶𝘃𝗲 𝗩𝗶𝗸𝘁𝗼𝗿 𝗢𝘄𝗻𝗲𝗿𝘀𝗵𝗶𝗽 We gave Viktor, our AI employee, responsibility for coordinating developer onboarding. Instead of having our engineers manually track every outstanding request, Viktor now: >Tracks outstanding setup tasks. >Collects relevant architecture documentation. >Follows up with responsible teammates. >Flags blockers that need human approval. Our engineers still approve access and review code. Viktor handles the coordination around those decisions. 𝟯. 𝗠𝗲𝗮𝘀𝘂𝗿𝗲 𝘁𝗵𝗲 𝗢𝘂𝘁𝗰𝗼𝗺𝗲 Over 7 days, Viktor coordinated 5 onboarding tasks for our new developer. Rather than spending as much time chasing updates, our team could focus on development while Viktor kept the onboarding process moving. It's a small example, but it points to a bigger shift: engineering teams will increasingly measure AI employees by the coordination work they take off people's plates. A copilot helps you work. An AI employee works when you don't. Hire @viktor_com for your team. $100 in credits included, no card. Full link in first comment. #AIemployee #SoftwareEngineering Paid Partnershipfrozen8d ago1.8K905000.77%
I got 3 hours back per week while building my tiny AI agent. (And I did it by hiring an AI employee.) Everyone thinks building an AI agent is about choosing the right model. Writing better prompts and/or connecting more tools. No. Building an AI agent requires planning, testing & tracking progress. And what I love about this is... you don't need a large engineering team to get started. You see, I'm building a tiny AI agent from scratch. And documenting every step in a newsletter so others can build along. But before I can explain how AI agents work, I need to build one myself. Most people underestimate this part. They focus on writing code without tracking decisions. Add features without documenting why. Start writing tutorials before testing the implementation. And they wonder why their projects become difficult to manage. So I hired an AI Engineering Project Coordinator. His name is Viktor, and he's my new AI employee. I gave him 3 responsibilities: 1. Track the development. ↳ Keep a record of tasks, milestones & blockers as I build the agent. 2. Coordinate the documentation. ↳ Track architecture decisions, implementation progress & topics I need to explain in the newsletter. 3. Keep the project moving. ↳ Follow up on unfinished work, prepare progress updates & flag decisions that need my attention. I still design architecture, write code & review results. Viktor coordinates the work around them. In 7 days, Viktor coordinated 8 engineering tasks across development, documentation & newsletter preparation. i,e., I got 3 hours back to focus on building the agent. I used to think building a small project meant handling every part of it myself. Now I spend more time building the agent & teaching others how it works. I think more software engineers will start working this way. If you're building software, hire @viktor_com for your team. Start free, no credit card. #AIemployee #SoftwareEngineering Paid Partnership1d ago1.8K922040.96%
If you're building open-source AI (in Europe), then you need to read this: Nebius AI Builder Program is expanding to Europe, with $10M across compute grants, capital & community. What it supports: → Founder funding from Accel & other European VCs → Support for open models, inference & coding agents → Hackathons & demo days with European AI communities → Projects focused on evaluation, post-training & data tooling → Compute grants for open-source AI research & developer tooling I've been mapping the production AI stack & open evaluation tools are one area I'd like to see more builders tackle. If you're building something in this space, check eligibility criteria & apply. https://t.co/3rTpxCcUnDfrozen4d ago1.7K1323031.26%
If you’re building AI agents (in 2026), you need to read this: An AI agent uses a model, tools & context to plan & execute tasks toward a goal. Text-based decisions are relatively straightforward. But things get hard when agents need to interact with computers & browsers. Before: >Agents send screenshots to large models for decisions >Each browser interaction requires a model call >Repeated decisions increase latency & costs >Complex workflows require dozens of small decisions Now: >Agents interpret screenshots to understand what's on screen >Agents identify right buttons, fields & page elements >Agents make step-by-step decisions during browser tasks >Agents use faster, lower-cost models for computer interactions I want AI agents to interact with computers & browsers without spending so much time & resources on each decision. Nace AI's Drex Max is a multimodal decision model built for this. These are their benchmarks: • 67.59 Decision Index across 37 benchmarks vs 60.70 for Jev 1.14 • 88.3% on Mind2Web vs 86.5% for Jev 1.14 • 174 ms median latency vs 253 ms for Jev 1.14 on its vision benchmark • Up to 167× cheaper per token than models behind Claude, GPT & Gemini computer use I'm (genuinely) excited about how this model could make computer-use agents faster & more affordable. Try Drex Max: https://t.co/ciCK13yHMXfrozen3d ago1.6K1215031.28%
How to start a software engineering podcast (in 2026)? - Record 30 minutes to 2 hours of audio - Stop re-recording every podcast episode from scratch - Create a Professional Voice Clone with HeyGen - Use the HeyGen API to add your voice to apps & workflows Just get in the habit of creating podcast episodes (with your own voice, of course) and spend less time recording the same things over & over.2d ago1.6K912081.23%
$0.07 per million input tokens for Gemma 4 26B on Inworld Inference. Conversation history can make up a large share of input in a chat app, so input price is an important part of the cost.frozen8d ago1.5K700010.54%
an hour and a half a day, per user, that's Status. I kept expecting that to translate into an inference bill nobody could control, then Inworld brought it down ~95%frozen8d ago1.4K200010.22%
What should a research agent do when retrieval finds no answer? 1 Identify the missing evidence 2 Find people who can provide it 3 Run the research 4 Connect the findings to what is known Qualitate turns an empty search result into a research task.2d ago1.3K500030.63%
The most impressive part of AI is seeing a simple idea turn into a real business on Capafy, an AI Skill marketplace. You built it. You launched it. You posted videos. You attracted customers. You made your first sales. Now what? One creator built CloneCut, a Claude skill that helps people recreate viral video formats using their own photos & ideas. They promoted it through Instagram & TikTok, attracted paying customers, and saw some return for more. Now the creator reports over $289K in sales on Capafy in just 30 days. You don’t need to build a massive AI product to start a business. Sometimes a simple tool that solves a specific problem is enough to get started.1d ago1.2K301030.59%