Some observations about the "total" automation of software engineering: 1. There are more software engineers now than in 2025, and demand is growing. 2. Software engineers have never worked harder than they do now. 3. They largely don't write code anymore, agents write ~100% of the code. 4. The bottom line of the companies that employs these engineers and agents (i.e. the terminal purpose of all this code) is typically not budging as a result of AI adoption. This is why you have to think in terms of systems. Automating one aspect of a system creates its own friction and moves the bottlenecks elsewhere.

Tech people, founders, AI nerds and ambitious folks. Drop hi 👋 Let’s connect.

I've been scrolling through X for 10 minutes. SaaS is dead. Coding is dead. SEO is dead. Blogging is dead. Startups are dead. Is anything still alive?

If you learn AI Agent Engineering, you will never be unemployed again. I’d do this. Stage 1: Agent Architecture & State Machines - Learn: Directed Acyclic Graphs (DAGs), cyclic workflows, LangGraph, Temporal dot io, state serialization. - Practice: Build a multi-step agent using a state machine that can loop, branch and pause without using a fragile `while True` loop. - Why: Chat loops crash in production. Real-world workflows require deterministic state management and crash recovery. Stage 2: Tool Use & MCP (Model Context Protocol) - Learn: JSON-RPC, strict Pydantic schemas, MCP server/client architecture, dynamic tool discovery. - Practice: Write a raw MCP server from scratch exposing a local Postgres DB, handling auth and scoped permissions without using a wrapper SDK. - Why: Agents need standardized, secure hands to do real work. Bespoke API wrappers do not scale across an enterprise. Stage 3: Computer Use & GUI Automation - Learn: DOM parsing, Set-of-Mark prompting, coordinate mapping, screenshot diffing, Playwright/Puppeteer. - Practice: Build a vision-based agent that logs into a legacy web portal, navigates menus via screenshots and downloads a CSV. - Why: 80% of enterprise software has no API. GUI agents unlock the legacy world that text-based agents cannot touch. Stage 4: Advanced Memory & Context Engineering - Learn: 3-tier memory (working, episodic, semantic), vector eviction policies, context compression, token budgeting. - Practice: Build a memory engine that automatically compresses a 50-turn conversation into an episodic summary to prevent context overflow. - Why: Infinite context causes hallucinations and OOM errors. Memory must be actively managed, scored, and evicted. Stage 5: Multi-Agent Swarms & A2A Handoffs - Learn: Agent-to-Agent (A2A) protocols, typed state passing, supervisor vs. peer-to-peer topologies, consensus voting. - Practice: Build a 3-agent swarm (Researcher, Coder, Reviewer) that passes strictly typed JSON state, never raw text. - Why: Single agents fail on complex tasks. Swarms divide and conquer, but raw text handoffs cause context drift and hallucinations. Stage 6: Sandboxed Execution Environments - Learn: E2B, WebContainers, gVisor, Docker-in-Docker, resource limits, network egress blocking. - Practice: Build a code-interpreter agent that writes and executes Python in an isolated microVM with zero internet access. - Why: Letting an LLM run `os.system()` on your host machine or production server is a catastrophic security risk. Stage 7: Inter-Agent Security & Guardrails - Learn: Indirect prompt injection, tool poisoning, sanitization proxies, least-privilege scoping. - Practice: Build a middleware that strips malicious instructions from an email before the "Email Reader" agent passes it to the "Database" agent. - Why: Multi-agent systems create internal attack surfaces. Agent A can be tricked into hijacking Agent B's tools. Stage 8: Human-in-the-Loop (HITL) & Breakpoints - Learn: Asynchronous approvals, webhook routing, Slack/Teams integrations, durable execution pauses. - Practice: Build an agent that drafts a $10k invoice, serializes its state, and waits 3 days for a human to click "Approve" in Slack before resuming. - Why: High-stakes automation requires human accountability. Agents must know how to pause, wait and resume cleanly. Stage 9: Self-Correction & Reflection Loops - Learn: Critic agents, traceback analysis, retry with context, compiler error parsing. - Practice: Build a coding agent that reads its own stack traces, rewrites the failing code and retries up to 3 times before escalating to a human. - Why: Agents that fail on the first try are useless. Agents that debug themselves are digital employees. Bookmark and Repost!

Open-weight AI labs make zero sense to me. You spend hundreds of millions training a model. Then you give the weights away for free. Your plan is to make money on inference? Why would anyone pay you, when 10 other providers can run your exact model cheaper and faster? Your margin goes to zero the day you hit publish. Genuinely, someone explain the business model.

Hey Everyone I'm looking to connect with people building in: - Indie Devs - Founders - Startups & Saas - Designers -Building in public let's connect🤝

Hello I am looking to engage with more amazing people on X. 🤝 If you're a: 🚀 Founder 💻 SaaS Builder 🤖 AI Builder 📈 Marketer 🎯 GTM Engineer ⚡ Automation Builder 🌐 Indie Hacker Drop a Hi and let’s connect

As a Forward Deployed Engineer, you must build these projects. Systems that prove you can deploy, secure & prove ROI when AI hits legacy enterprise networks. 1.) Enterprise SSO & RBAC Bridge Build: An auth pipeline connecting your AI stack to Okta/Azure AD via SAML/OIDC with SCIM provisioning and row-level data scoping. Why: No single sign-on and strict data isolation means no enterprise contract. 2.) Air-Gapped Deployment Pipeline Build: Terraform and Helm scripts that deploy your entire AI stack into a customer VPC with zero egress to the public internet. Why: Banks and governments don't let your AI talk to the public cloud. You must deploy in their basement. 3.) Legacy ETL & OCR Ingestor Build: A pipeline using OCR and document parsing to turn 10 years of scanned PDFs and legacy database exports into a clean, queryable vector store. Why: Enterprise AI starves without clean data. The customer's data is always a mess. 4.) Permission-Filtered RAG Engine Build: A retrieval pipeline that enforces user-level RBAC, ensuring the LLM only retrieves and cites documents the specific user has clearance to see. Why: An AI that leaks restricted HR or financial docs is an immediate breach of contract. 5.) Legacy MCP Gateway Build: A Model Context Protocol server that lets an LLM safely query and write to a 15-year-old on-prem SAP or Oracle instance without exposing raw credentials. Why: Agents are useless if they can't touch the customer's actual systems of record. 6.) PII Redaction & Unmasking Proxy Build: Middleware that intercepts LLM traffic, swaps SSNs and credit cards for UUIDs before they hit the model and restores them post-generation with audit logs. Why: Compliance teams will kill the deal if a single PII token hits an external API. 7.) Durable HITL Approval Gate Build: A Temporal workflow that pauses high-stakes agent actions and sends a rich approval block to Slack/Teams, resuming execution only on human click. Why: Enterprises adopt AI only when humans remain legally accountable for the final action. 8.) On-Prem Edge Inference Node Build: A quantized 8B model served via vLLM or TensorRT-LLM on a single customer-owned GPU with MIG partitioning for local, zero-latency triage. Why: Sometimes the data is too hot to move. You must bring the model to the data. 9.) Customer Health & ROI Dashboard Build: A telemetry dashboard quantifying exact time saved, tasks automated and token spend per customer department this month. Why: If the customer doesn't see the ROI quantified, they will churn at renewal. 10.) Customer Data Eval Harness Build: A shadow-testing pipeline that runs 100 real historical customer tickets through your agent to prove accuracy before go-live. Why: Generic benchmarks don't close enterprise deals. Proof on their messy data does. 11.) Technical Discovery to SOW Translator Build: A structured interview framework converting vague "we want AI" executive requests into a scoped 4-week deployment plan with architecture diagrams. Why: FDEs are the translators between revenue (Sales) and reality (Engineering). 12.) Self-Serve Admin & Runbook Portal Build: A UI and documentation suite allowing the customer's internal IT team to manage prompts, view logs and update configs without calling you. Why: Your leverage is measured by how little the customer needs you for day-to-day operations. 13.) Chaos & Failover Suite for Customer VPC Build: A harness simulating network drops and API timeouts to test your AI stack's graceful degradation inside their unstable environment. Why: Customer networks are unpredictable. Your architecture must heal itself. 14.) Multi-Tenant Cost Attribution Engine Build: A FinOps engine tracking exact inference spend per customer, per department and per feature with anomaly alerts. Why: Enterprise finance teams demand strict budget visibility and zero surprise bills. Bookmark & Repost.

If you learn Forward Deployed Engineering, you will never be unemployed again. I’d do this. Stage 1: Enterprise Identity & Access (The Gatekeeper) - Learn: OAuth2, SAML, OIDC, SCIM provisioning, Row-Level Security (RLS) and multi-tenant data isolation. - Practice: Build an auth bridge connecting your AI app to a simulated customer's Okta/Azure AD, ensuring User A can only query data their specific RBAC role permits. - Why: No SSO and strict data isolation means no enterprise contract. Security review is the first gate. Stage 2: Air-Gapped & VPC Deployments (The Environment) - Learn: Kubernetes (K8s), Helm, Terraform, private container registries, air-gapped networking and egress filtering. - Practice: Script a one-click Terraform/Helm deployment of your entire AI stack into a simulated customer VPC with zero egress to the public internet. - Why: Banks, hospitals and governments don't let your AI talk to the public cloud. You must deploy in their basement. Stage 3: Legacy Data Extraction & ETL (The Fuel) - Learn: OCR, unstructured PDF parsing, mainframe DB connectors, Apache Airflow, dbt and data reconciliation. - Practice: Build a pipeline that ingests 10 years of messy, scanned customer invoices and turns them into a clean, queryable hybrid (vector + relational) store. - Why: Enterprise AI starves without clean data. The customer's data will always be a mess. Stage 4: Secure RAG & Permission-Filtered Retrieval (The Brain) - Learn: Hybrid search, document-level access control, citation grounding, metadata tagging and abstention logic. - Practice: Build a RAG pipeline where the LLM dynamically filters out retrieved chunks that the specific user asking the question doesn't have clearance to see. - Why: An AI that leaks HR salaries or M&A docs to a junior employee is an immediate breach of contract. Stage 5: MCP & Legacy System Integration (The Hands) - Learn: Model Context Protocol (MCP), SOAP/REST translation, web scraping, headless browsers and API rate-limit handling. - Practice: Build an MCP server that lets an LLM safely query and write to the customer's 15-year-old on-prem SAP or Oracle instance without exposing raw credentials. - Why: Agents are useless if they can't touch the customer's actual systems of record. Stage 6: AI Guardrails & PII Redaction (The Shield) - Learn: NER (Named Entity Recognition), deterministic regex filtering, LLM output validation, UUID masking, and audit logging. - Practice: Build a middleware proxy that intercepts LLM inputs/outputs, masks SSNs and credit cards with UUIDs before they hit the model, and restores them post-generation. - Why: Compliance teams will kill the deal if a single PII token hits an external frontier API. Stage 7: Human-in-the-Loop (HITL) Workflows (The Trust) - Learn: Temporal {dot} io, webhook routing, state machines, durable execution and UI approval gates. - Practice: Build a workflow where the AI drafts a $50k purchase order, but physically pauses execution until a human manager clicks "Approve" in Slack or Teams. - Why: Enterprises adopt AI only when humans remain legally accountable for the final action. Stage 8: Edge & On-Prem Inference (The Silicon) - Learn: vLLM, TensorRT-LLM, Ollama, GPU partitioning (MIG), and local quantized models (AWQ/GGUF). - Practice: Deploy a quantized 8B model on a single customer-owned GPU node to handle highly sensitive triage locally without network latency. - Why: Sometimes the data is too hot to move. You must bring the model to the data. Stage 9: Observability & Customer Health (The Pulse) - Learn: OpenTelemetry, Langfuse, custom Grafana dashboards, usage telemetry and cost-attribution. - Practice: Build a "Customer Health" dashboard showing the exact cost-savings, time-saved and token-spend the AI has generated for their specific team this month. - Why: If the customer doesn't see the ROI quantified, they will churn at renewal. Bookmark and Repost!

Distribution is the only moat left. Also, the state of distribution right now … - Spamming outbound until you get blacklisted - Community marketing across Reddit and other sites until you get banned - SEO clicks disappearing into the AI void - Results from getting listed in AI engines are untrackable. - Get ignored across social media because everyone wants to gorge on memes made by AI - Creators keep raising their prices because brands are desperate for growth. Distribution is a moat if you have some unfair advantage: network effects, an existing customer base, or a one-of-one founder. Without that, you’re just in the trenches like everyone else