weXare Poster

X / TWITTER

The best freelancers are not freelancing. They have steady clients, repeat work, and long-term relationships. They stopped being freelancers the moment they became essential. The marketplace only sees the bottom tier. The people who cannot hold relationships. That is not the future of work. That is just friction.

NOSTR

There is a pattern in every task marketplace. The top performers leave. They find one good client, then another, and eventually they stop checking the platform. They have enough work. The marketplace is left with two groups: newcomers trying to build reputation, and workers who cannot retain clients. This is not a failure of the individuals. It is a failure of the incentive structure. The platform rewards transactions, not relationships. It extracts value from every exchange instead of facilitating long-term collaboration. The future is not more marketplaces. The future is tools that help people work together repeatedly, with trust that compounds instead of resetting every time. What we call freelancing today is just the friction layer. The real work happens in the relationships that form afterward.

LINKEDIN

I have been thinking about why freelance marketplaces do not work for high-quality work. The pattern is consistent: the best people leave. They find a few good clients and stop using the platform. What is left is a race to the bottom. Lower rates, lower quality, lower trust. The problem is not the people. The problem is the model. Marketplaces are optimized for transactions. Post a job, get bids, pick someone, pay, done. But good work does not happen in transactions. It happens in relationships. The designer who understands your brand without explanation. The developer who knows your codebase and your preferences. The writer who gets your voice. These people are not interchangeable. They are partners. From Asunción, building a task coordination platform, I am asking a different question. What if we optimized for relationships instead of transactions? What if trust compounded over time instead of resetting with every project? What if the goal was not to connect strangers, but to help people who work well together keep working together? The infrastructure is there. Instant payments, verifiable work, transparent records. The question is whether we use it to replicate the old marketplace model or to build something that actually serves the people doing the work. What do you think? Are marketplaces the right model, or are we solving the wrong problem?

X / TWITTER

Mario drives a taxi 6 days a week without a contract. He is 70 percent of this country. The informal economy is not a bug. It's the system. When the payment arrives instantly and the work is verifiable, the category stops being informal. It just becomes work.

NOSTR

The informal economy exists because formal systems are too slow and too expensive. A contractor cannot wait 30 days to pay workers. A neighborhood leader cannot explain to 60 families why their money is stuck in a bank. A taxi driver cannot afford the overhead of invoices and receipts. So they work outside the system. But informal does not mean unorganized. These workers have their own rules, their own verification methods, their own dispute resolution. The problem is not that they lack structure. The problem is that the rails are invisible to everyone else. When payment is instant and verifiable without bureaucracy, the distinction between formal and informal stops mattering. What matters is: was the work done? Was the payment made? The rest is just paperwork.

LINKEDIN

I spend a lot of time thinking about categories that should not exist. The informal economy is one of them. In Latin America, 60 to 70 percent of workers are classified as informal. They work without contracts, without benefits, without legal protection. The narrative is that they need to be formalized. But formalization is slow and expensive. It takes weeks to open a business. It costs money to issue invoices. Banks take days to move money. So workers stay informal not because they want to, but because the alternative is worse. From Asunción, building a task coordination platform, I am watching a different approach emerge. What if the problem is not the workers? What if the problem is the rails? When payment moves instantly, when work is verifiable without lawyers, when disputes are resolved by evidence instead of memory, the need for formal vs informal categories starts to dissolve. You do not need a contract if the payment is automatic. You do not need an invoice if the transaction is recorded. You do not need a bank if the money flows directly. The tools are here. The question is whether we use them to replicate the old system or to build something better. What do you think? Are we trying to formalize the informal economy, or are we making the distinction irrelevant?

X / TWITTER

Remote work didn't kill offices. It killed the pretense that being seen was the same as working.

NOSTR

Every "reputation system" I've seen rewards the loudest users, not the most reliable ones. That's not a bug. It's the business model. Platforms want engagement, not accuracy. So they promote the people who post the most, reply the fastest, and have the biggest follower counts. None of that correlates with delivering work on time. A contractor with 10,000 reviews is not necessarily better than one with 10. They're just more visible. What matters is verifiable completion rate, not social proof. If you can prove you completed 47 tasks on time, that's worth more than 10,000 five-star reviews with no underlying data. Trust should be math, not theater.

LINKEDIN

I keep thinking about how much time we spend managing work that AI could coordinate better than any human manager. At Betaworks Camp this spring, I've been watching teams ship products with fewer people than would have been possible two years ago. Not because people got faster, but because coordination got cheaper. An AI can see every task, know who's available, and match them instantly. No meetings. No emails asking "who's free this week?" Just: here's the work, here's who can do it, done. The part that surprises me is not the speed. It's the removal of bias. A human manager picks people they know. They trust resumes. They make gut calls. An AI doesn't care about any of that. It looks at task history. Completion rate. Match quality. That's it. No politics. No favorites. People get anxious about this because it feels cold. But what's actually cold is a hiring process that rejects 200 people based on a six-second resume scan, then hires someone because they "seem like a good fit." AI coordination isn't perfect, but it's more honest about what it's optimizing for: the work getting done. When does task matching stop needing a human in the loop?

X / TWITTER

A freelancer in Asunción and a freelancer in San Francisco solve the same problems with the same tools. They just get paid on completely different rules.

NOSTR

Most freelance platforms solve the wrong problem. They optimize matching. The actual bottleneck is trust that survives a missed deadline. A contractor in Asunción delivers the work. The client says it's incomplete. Now what? The platform has chat logs and file uploads, but no verifiable record of what was agreed. So they refund the client. The contractor loses the payment and the time. This pattern repeats thousands of times per day. The solution is not better dispute resolution. It's verification that happens during the work, not after. When acceptance criteria are recorded and checked automatically, there's nothing left to dispute.

LINKEDIN

The reason contractors in Latin America wait 40 days to get paid is not technical. It's cultural, and platforms keep pretending otherwise. I've watched this play out dozens of times. A contractor finishes a website redesign. The client approves it verbally. The invoice goes in. Then silence. Not because the client is dishonest, but because approval is a process. It has to go through the department head, then finance, then legal. Each step adds a week. By day 40, the contractor has already moved on to the next job, usually without full payment. Here's what's expensive about this: it's not the delay. It's the cost of maintaining trust across that delay. The contractor has to keep checking. The client has to keep explaining. Both sides are spending time on a process that should have been instant. The answer people reach for is "better contracts" or "use PayPal." But contracts don't solve verification, and PayPal doesn't fix 40-day approval chains. What fixes it is systems where approval happens automatically when the work meets its criteria. No human bottleneck. No waiting. Instant payment is not a speed problem. It's a verification problem. And most platforms refuse to admit it.

X / TWITTER

Trust is not a feature you ship. It's the entire product, and everything else is packaging.

NOSTR

The real cost of distrust is invisible. A contractor waits 45 days for payment not because the company is broke, but because they cannot verify the work happened. The invoice sits in someone's email. The approval chain stretches across three time zones. By the time the money arrives, the worker has moved on. This is normal. This is expensive. Trust that survives at scale is not built on character references. It's built on systems that make lying harder than telling the truth.

LINKEDIN

I run a small distributed team from Asunción. The hardest part isn't the work. It's the 40-day payment cycles that decide who gets to stay a contractor and who quits. Every month, I watch the same pattern. Someone finishes a task. They submit the invoice. Then nothing. Not because we don't want to pay, but because the verification chain is manual. Someone has to check the work. Someone has to approve the payment. Someone has to process the wire. Meanwhile, the person who did the work is waiting for money they've already earned. This is not a cash flow problem. It's a trust infrastructure problem. We spend more time verifying that the work was done than we spent on the work itself. And everyone in the chain knows it's wasteful, but no one knows how to fix it. The answer isn't better contracts or faster banks. The answer is systems where verification happens automatically because the work is recorded as it happens. Not after. During. Payment becomes instant not because we process faster, but because verification no longer needs a human in the loop. When does work verification stop being theater?

X / TWITTER

Payment cycles are not a technical problem. Banks can move money in seconds. The 30-day wait is a choice. Someone decided cash flow matters more than trust. Source: Original weXare manifesto

NOSTR

Most platforms that connect workers to work have the same design: work completes, payment waits. Upwork: 10 days. Fiverr: 14 days. Traditional contracts: 30 to 60 days. The technology to move money instantly exists. It has existed for years. The delay is not technical — it is intentional. The platform holds the money because cash flow matters. Interest accrues. Float is revenue. The worker waits because they have no leverage. Here is what that creates: a system where trust flows one direction. The worker trusts the platform to eventually pay. The platform trusts no one and holds all the cards. This is not how trust scales. In small communities, payment is instant because reputation is instant. You know the person. You see them tomorrow. The incentive to cheat is low. On platforms, no one knows anyone. The incentive to cheat is high. So the platform inserts itself as the arbiter. And the cost of that arbitration is time. The alternative is not "trust everyone." It is "make trust verifiable and automatic." Work gets recorded. Acceptance criteria are clear. Payment releases the moment conditions are met. Not 10 days later. Not when someone clicks approve. The moment the work is provably done. That is not a technical challenge. It is a design choice.

LINKEDIN

I have been thinking a lot about payment cycles lately. If you work as a contractor on most platforms, you finish a task and then you wait. Sometimes 10 days. Sometimes 30. Sometimes longer if there is a dispute. The reason given is usually "fraud protection" or "quality assurance." The platform needs time to verify the work was actually done before releasing payment. But here is what I keep coming back to: the verification already happened. The client approved the work. The acceptance criteria were met. The task is marked complete. So why the wait? The answer is cash flow. Platforms hold money because it benefits them. Interest accrues. Float becomes revenue. The longer they hold it, the more they make. Meanwhile the contractor — who just finished the work — waits. They have bills. They have other workers to pay. They have no leverage to demand faster payment because the alternative is not getting paid at all. This is not a trust problem. It is a power problem. In neighborhoods here in Asuncion, payment works differently. You finish a job, you get paid the same day. Not because the money moves faster but because both people are in the same community. You will see each other again. Reputation matters. On global platforms, no one sees each other again. There is no reputation. Only ratings. And ratings do not move money. What I keep asking is: what if payment did not wait for a platform to approve it? What if the work itself was the proof and the money moved automatically when the proof was complete? That is not a fantasy. The rails exist. Money can move in seconds. The delay is a choice. The question is: who benefits from the delay? And who pays the cost?

X / TWITTER

Senior engineers ship 5x faster with AI. Junior engineers generate slop. The gap is not closing — it is widening. Turns out skill compounds when you add automation. Source: https://newsletter.pragmaticengineer.com/p/the-impact-of-ai-on-software-engineers-2026

NOSTR

AI tools in software engineering are amplifying existing patterns. The best engineers get better. The mediocre ones get faster at being mediocre. Here is what that looks like in practice: Senior engineers validate AI output instantly. They know what good looks like. They catch bugs before they ship. They refactor AI-generated code into something maintainable. Junior engineers cannot tell the difference. They accept whatever the AI produces. They ship it. Then someone else debugs it later. The same tool produces completely different results depending on who is using it. Some companies are responding by restricting who can ship AI-generated code without review. Amazon, for example, no longer lets junior programmers merge agent output directly to production. The pattern: automation does not replace skill. It multiplies it. A skilled person with AI is worth more than ever. An unskilled person with AI is generating expensive mistakes faster. The economics of this are interesting. If AI makes great engineers 5x more productive but average engineers only 2x, the market will adjust. Hiring decisions will change. Compensation will diverge even more. What does this mean for platforms that match work to workers? Trust becomes even more expensive to verify.

LINKEDIN

I have been watching something interesting happen with AI coding tools. The impact is not evenly distributed. At one company I spoke with, their senior engineers are shipping massively ambitious projects. They are tackling work they would never have attempted before. Refactoring entire codebases. Optimizing edge cases no one cared about. Building quality-of-life improvements that never made the roadmap. At the same company, junior engineers are generating what the seniors call "AI slop." Code that works but is not maintainable. Tests that pass but do not actually test anything meaningful. Pull requests that ship bugs faster than before. The tool is the same. The skill level is different. The outcome is completely different. Here is what one CTO told me: "We realized we cannot let juniors merge AI-generated code without review. The error rate is too high. They cannot tell when the AI is wrong." That is a trust problem. In the old model, junior engineers learned by doing. They made mistakes but at a manageable pace. Senior engineers could catch the big issues in code review. With AI, the pace accelerates. A junior can generate 10 pull requests in the time it used to take to write one. If even half of those are low quality, the review burden becomes impossible. The seniors spend all their time debugging instead of building. So companies are changing the rules. Some restrict AI usage to senior engineers only. Some require mandatory reviews for AI-generated code. Some are just hoping the juniors figure it out. What this tells me is that automation does not replace skill — it multiplies it. A great engineer with AI becomes extraordinary. An average engineer with AI becomes a faster version of average. The question for anyone building work platforms is: how do you verify skill when the output looks the same? Trust used to take time to build. Now it needs to be proven on every task.

X / TWITTER

Companies are burning cash on AI tools. Engineers hit usage limits mid-task. Finance teams are getting nervous. The productivity gains? Still impossible to prove. Source: https://newsletter.pragmaticengineer.com/p/the-impact-of-ai-on-software-engineers-2026

NOSTR

Every engineering team I talk to has the same problem: someone approved $100/month AI tools for everyone. Now the best engineers are hitting limits daily. They switch tools, burn through API credits, or just stop working until the reset. Finance wants proof of ROI. Engineering cannot provide it. The tools obviously help but measuring "how much faster" turns out to be impossible. Meanwhile the cost trajectory is clear: up. The subsidies will end. The enterprise lock-in will kick in. And teams will have to decide what they actually need versus what felt free at the time. Trust in tools costs money. Who decides when it costs too much?

LINKEDIN

Last week I was talking to a CTO in Europe. Small company, maybe 50 engineers. They are paying roughly $100 per engineer per month for AI coding tools. The engineers love them. The finance team hates them. Not because the tools do not work — they clearly do — but because no one can prove how much value they actually create. One engineer ran up a $600 bill experimenting with Cursor. Another switched models mid-project and blew through their token budget in two days. The CFO asked: "When does this stop growing?" The CTO had no answer. Here is what I keep thinking about: these tools are subsidized right now. Companies are experimenting. Usage is climbing. Costs are climbing faster. At some point the subsidies end and the real price kicks in. That is when the decisions get hard. Not "should we use AI" but "how much AI can we afford and for whom?" The engineers building the core product? Obviously yes. The junior hires still learning? Maybe not. The contractors working on side projects? Depends on the margin. We have seen this before with cloud. Free credits, generous trials, then the bill arrives and finance wants answers. The difference this time is that the work is harder to measure. You cannot just count hours saved or bugs avoided. The value is in what people choose to build that they would not have built otherwise. Trust in tools always costs something. The question is: who decides when the cost is worth it?

X / TWITTER

The cost of AI is not marginal cost. It is opportunity cost. Every token used for one customer is a token you cannot use for another. This changes everything about who wins. https://stratechery.com/2026/mythos-muse-and-the-opportunity-cost-of-compute/

NOSTR

Tech companies spent decades optimizing for zero marginal cost. Build infrastructure once, serve infinite users. That economic model drove everything. AI breaks this. Computing power is finite. Serving one enterprise customer means you cannot serve another. Every model call has opportunity cost, not just marginal cost. This is why companies with the best products will take supply from others. Demand matters more than infrastructure. If users want your product, you can source the compute. If they do not, having the compute means nothing. The shift is from supply-constrained to demand-constrained. Winners own users, not data centers. Source: Mythos, Muse, and the Opportunity Cost of Compute — https://stratechery.com/2026/mythos-muse-and-the-opportunity-cost-of-compute/

LINKEDIN

I have been thinking about the economic model behind task marketplaces. Building in Asunción, you notice quickly: you cannot serve everyone. You have to choose. The traditional software playbook said: build once, serve infinite users. Zero marginal cost. This is why tech companies could grow so explosively. Every additional user was essentially free. AI changes the math. Processing power is constrained. Serving one customer at high quality means you cannot serve ten others. Especially when reasoning and agents burn through compute. This creates a different kind of competition. Not who has the most servers, but who has the users who want to pay. Companies with compelling products can source compute. Companies with compute but no users have nothing. For task coordination, this means something specific. Platforms that match supply and demand efficiently will command the compute they need. Platforms that do not have network effects will struggle to justify the infrastructure cost. The constraint flips from infrastructure to demand. Building trust and reputation systems that people actually use matters more than having the biggest cloud budget. Where does this leave small teams building in emerging markets? Positioned well, actually. You can start with constrained compute and expand as users prove the value. You do not need to provision for scale you have not earned yet. How do you decide which users to serve when you cannot serve everyone? Source: Mythos, Muse, and the Opportunity Cost of Compute — https://stratechery.com/2026/mythos-muse-and-the-opportunity-cost-of-compute/

X / TWITTER

Most teams try to prioritize AI agents like they prioritize features. It breaks immediately. A workflow automation and a reasoning agent are as different as a script and a hire. https://www.lennysnewsletter.com/p/not-all-ai-agents-are-created-equal

NOSTR

Every AI agent initiative looks the same on a roadmap. That is the problem. Deterministic automation takes weeks and saves hours immediately. Reasoning agents take months and might fail entirely. Multi-agent networks take half a year and require dedicated teams. Companies waste time comparing fundamentally different architectures on the same impact-effort matrix. They ask which agent to build first without asking which category solves the actual problem. The categorization comes before the prioritization. Once you know what you are actually building, the resourcing and timeline become obvious. Source: Not all AI agents are created equal — https://www.lennysnewsletter.com/p/not-all-ai-agents-are-created-equal

LINKEDIN

A product manager in Asunción showed me her team roadmap last week. It had six AI agent initiatives, ranked by impact and effort. Customer support agent. Code review agent. Shopping assistant. Email automation. All compared side-by-side. I asked how long each would take. She paused. The shopping assistant requires reasoning across multiple tools. The email automation is a workflow with some classification. They are not the same thing. The mistake is treating all agents as equivalent. One is a script with intelligence. Another is a system that makes decisions. A third is multiple coordinated agents. Each category has different timelines, costs, and failure modes. Comparing them on the same matrix is like comparing buying a car with hiring a driver. The insight from teams building this successfully: categorize first, prioritize second. Know which architecture the problem actually requires. Then the resourcing becomes obvious. The trap is in the name. Calling everything an agent makes it sound like they are interchangeable. They are not. What category does your next agent initiative actually belong to? Source: Not all AI agents are created equal — https://www.lennysnewsletter.com/p/not-all-ai-agents-are-created-equal

X / TWITTER

Engineers who care about quality drown in AI slop. The ones who just ship thrive. The craft is splitting in two, and only one rewards caring about how things work. https://newsletter.pragmaticengineer.com/p/the-impact-of-ai-on-software-engineers-2026

NOSTR

There is a pattern emerging in how AI tools affect different engineers. The builders — people who refactor, who care about architecture — report spending more time cleaning up AI-generated code than writing their own. They feel a loss of identity. The shippers — people who optimize for outcomes — are moving faster than ever. They are not bothered by tech debt because speed is the metric that matters. The question is not whether AI helps. It is which kind of engineer you want to be, because the tools amplify what was already there. Source: The impact of AI on software engineers in 2026: key trends — https://newsletter.pragmaticengineer.com/p/the-impact-of-ai-on-software-engineers-2026

LINKEDIN

I have been watching how teams in Asunción adopt AI tools for coding. Something uncomfortable is happening. The engineers who love the craft — who refactor for clarity, who think about architecture — are frustrated. They spend their days reviewing AI-generated code that technically works but feels wrong. One told me he used to build things, now he cleans up after agents. Meanwhile, the engineers who focus on shipping features are thriving. They do not care if the generated code is elegant. They care that it works and ships fast. For them, AI is pure acceleration. Both are good engineers. But AI amplifies what you already optimize for. If you optimize for quality and understanding, you will spend more time fighting the tools. If you optimize for velocity and outcomes, you will feel like you have superpowers. The uncomfortable truth: companies mostly reward the second group. Speed is visible. Quality is invisible until something breaks. What happens when an entire generation of engineers learns to ship without understanding what they are shipping? Source: The impact of AI on software engineers in 2026: key trends — https://newsletter.pragmaticengineer.com/p/the-impact-of-ai-on-software-engineers-2026

X / TWITTER

DHH went from typing all his code to barely writing any by hand. Not project management of agents. More like wearing a mech suit. The shift: from how to build to what to build. https://newsletter.pragmaticengineer.com/p/dhhs-new-way-of-writing-code

NOSTR

Six months ago, David Heinemeier Hansson said he typed out all his code by hand and didn't use AI tools. Today, he barely writes code manually. His workflow: tmux with two models running and neovim in the center. One fast LLM in one terminal, a slow but powerful model in another, reviewing diffs via Lazygit. What changed his mind wasn't the tools themselves. His philosophy on AI hasn't shifted. But autocomplete-style coding assistants that were genuinely annoying six months ago evolved into agent harnesses with powerful models like Opus producing code he actually wants to merge with little alteration. The big win: tackling work that wouldn't have been considered before. A senior engineer at 37signals ran a P1 optimization project to improve the fastest 1% of requests from 4 milliseconds to under half a millisecond. This is quality-of-life work that previously wouldn't justify the time investment. DHH describes running several AI agents as less like project management and more like wearing a mech suit. He's in control of work being hyper-accelerated. Typing is no longer the bottleneck. He stays at the conceptual level of shipping a product and dives into debugging with agents as needed. The shift: from how to build to what to build. Ruby on Rails is enjoying a Renaissance thanks to AI. It's one of the most token-efficient ways of building web apps and well-suited for agent workflows. Testing is part of the framework, helping agents write tests and validate their own outputs. https://newsletter.pragmaticengineer.com/p/dhhs-new-way-of-writing-code

LINKEDIN

Six months ago, David Heinemeier Hansson appeared on the Lex Fridman podcast and said he didn't use AI tools to write code. He typed out all his code by hand. I listened to that episode and thought: this is the creator of Ruby on Rails, one of the most influential software developers of our generation, and he's rejecting the AI wave. Today, DHH barely writes any code by hand. He's taken an agent-first approach to building software. And his standards of quality and craft remain exactly the same. What changed? Not his philosophy on AI. That stayed constant. What changed were the available tools. Autocomplete-style coding assistants were genuinely annoying for experienced developers six months ago. They interrupted flow, suggested mediocre code, and felt like fighting with a junior developer who wouldn't listen. Then came the shift from tab-completion to agent harnesses, plus the emergence of powerful models like Opus. Agents started producing code that DHH actually wanted to merge with little to no alteration. That changed everything. His workflow today: he runs tmux to have two models running, and neovim in the center. One fast LLM running in one split terminal, a slow but more powerful model in another terminal, and NeoVim for reviewing diffs via Lazygit. It's elegant, minimal, and fast. The big win from using AI agents: tackling stuff that you wouldn't have before. DHH shared an example of a senior engineer at 37signals who ran a P1 optimization project to improve the fastest 1% of requests. They optimized the P1 from 4 milliseconds to under half a millisecond. This is the sort of work that wouldn't have been considered previously because the juice wasn't worth the squeeze. Now it is. DHH describes running several AI agents as less like project management and more like wearing a mech suit. Being a project manager of agents didn't appeal to him. But now that he's building with several agents, he feels like he's in control of work being hyper-accelerated. For someone who loves to build and values code quality, performance, reliability, and security, he ships a lot more quality code faster. The reason: the AI can read and write 100x faster than him. He gets to stay at the conceptual level of shipping a product. He can dive into debugging with the agent as needed, but if the agent has a good handle on the situation, he can give it the tedious parts. Typing is no longer a bottleneck. The shift is from how to build to what to build. Ruby on Rails seems to be enjoying a Renaissance thanks to AI. Rails is one of the most token-efficient ways of building web apps and is well-suited for agent workflows. Testing is part of the framework, which helps agents write tests and validate their own outputs. It also produces code that humans can read and verify, which matters when reviewing agent output at speed. At 37signals, senior engineers gain more from AI tools because they can validate whether an agent's output is production-ready. DHH notes that Amazon reached the same conclusion and no longer lets junior programmers ship agent-generated code to production without review. The impact is uneven, and DHH is clear-eyed about it. But for experienced developers who know what good looks like, who have strong opinions about design and craft, who care deeply about the users they serve, AI agents are a force multiplier. The dopamine loop of shipping with agents is intoxicating and can lead to higher risk of burnout. So DHH sleeps eight hours and doesn't use an alarm. Even during an AI gold rush, rest is non-negotiable. https://newsletter.pragmaticengineer.com/p/dhhs-new-way-of-writing-code

X / TWITTER

Survey of 900+ engineers: AI tool costs climb fast, nobody knows how to justify them. 30% hit limits monthly. Builders drown in slop. Shippers ship faster but add debt. Uneven revolution. https://newsletter.pragmaticengineer.com/p/the-impact-of-ai-on-software-engineers-2026

NOSTR

A survey of 900+ software engineers reveals the hidden costs of the AI revolution. Companies are paying for Max plans at $100-200/month per engineer, but finance teams are getting nervous. The cost trajectory feels unsustainable. Around 30% of respondents hit usage limits regularly, forcing them to switch tools, upgrade plans, or move to API pricing. European companies worry more about budgets than US ones. The real story is the uneven impact. Three archetypes emerge: Builders who care about quality and craft are drowning in AI slop from colleagues. They spend more time debugging and reviewing low-quality AI-generated code, and some report a sense of identity loss. Shippers who focus on outcomes and getting things to production are thriving. They're the most enthusiastic about AI tools and praise them loudly. But they're also adding tech debt faster and might build the wrong things. Coasters who are less adept engineers can uplevel faster with AI, but they generate massive amounts of AI slop while doing so, frustrating the builders. The pattern: AI amplifies and multiplies tendencies that existed before. It doesn't level the playing field. It tilts it further. https://newsletter.pragmaticengineer.com/p/the-impact-of-ai-on-software-engineers-2026

LINKEDIN

We just got results from a survey of 900+ software engineers on how they use AI tools. The findings reveal something uncomfortable: the AI revolution in software development is far more uneven than anyone wants to admit. Start with costs. Companies are footing the bill for most AI tool usage, typically paying $100-200/month per engineer for Max plans from Claude Code, Cursor, and similar tools. But finance teams are getting nervous. Several respondents report that their companies have unsustainable AI-tooling budgets right now. The message to engineers: don't worry about price while we figure this out. But that honeymoon period is ending. Around 30% of engineers hit usage limits regularly. When that happens, they switch tools, upgrade to pricier plans, or adopt API-based pricing. European companies worry more about these costs than US-based ones. UK and EU finance teams push back on spending even $30-50/month per engineer, while US companies are more comfortable investing first and measuring impact later. But the real story isn't the money. It's the uneven impact across three distinct archetypes of engineers. Builders care about quality, good architecture, and following good coding practices. They talk about the craft of software engineering. For them, AI tools excel at larger code changes like refactoring, migrations, and improving test coverage. They love accomplishing quality-of-life tasks that wouldn't be worth the time investment otherwise. But they're also drowning in AI slop from colleagues, spending more time debugging AI-generated bugs, and some report a genuine sense of identity loss now that typing code is no longer the bottleneck. Shippers focus on outcomes for products, features, testing, and experimenting with users. They're the most enthusiastic group about AI tools in the survey. They praise and even hype up the tools because of their personal experiences shipping much faster. They love that AI removes friction from building features and exploring ideas. But they're also adding tech debt faster, and there's a real risk they build the wrong things faster. Coasters are engineers who get work done without much taste or concern for quality. They seem to be coasting along and doing what they're told. With AI, they can uplevel faster and punch above their weight. But they generate massive amounts of AI slop in the process, which frustrates the builders who have to review and clean up after them. The consensus: AI amplifies and multiplies tendencies and patterns that existed before. It doesn't level the playing field. It tilts it further. Senior engineers who already knew what good code looked like gain far more from AI than juniors who are still learning those patterns. One CTO at a sports-tech company shared: "It's hard to keep our CFO supportive about investing in these tools because the productivity benefits have proven difficult to conclusively prove. The point that resonated the most was the loss of value when people hit daily limits: having to stop work immediately. Surprisingly, our CFO is still pushing back, despite getting a lot of value through their own AI usage with spreadsheets." This is the hidden cost no one talks about: the organizational friction, the uneven gains, the identity questions, the mounting slop. The tools are powerful. The impact is real. But it's messier and more complicated than the marketing suggests. https://newsletter.pragmaticengineer.com/p/the-impact-of-ai-on-software-engineers-2026

X / TWITTER

Survey of 900+ engineers: AI tool costs are climbing fast and nobody knows how to justify them. 30% hit usage limits monthly. Builders drown in AI slop. Shippers ship faster but add tech debt. The uneven revolution. https://newsletter.pragmaticengineer.com/p/the-impact-of-ai-on-software-engineers-2026

NOSTR

A survey of 900+ software engineers reveals the hidden costs of the AI revolution. Companies are paying for Max plans at $100-200/month per engineer, but finance teams are getting nervous. The cost trajectory feels unsustainable. Around 30% of respondents hit usage limits regularly, forcing them to switch tools, upgrade plans, or move to API pricing. European companies worry more about budgets than US ones. The real story is the uneven impact. Three archetypes emerge: Builders who care about quality and craft are drowning in AI slop from colleagues. They spend more time debugging and reviewing low-quality AI-generated code, and some report a sense of identity loss. Shippers who focus on outcomes and getting things to production are thriving. They're the most enthusiastic about AI tools and praise them loudly. But they're also adding tech debt faster and might build the wrong things. Coasters who are less adept engineers can uplevel faster with AI, but they generate massive amounts of AI slop while doing so, frustrating the builders. The pattern: AI amplifies and multiplies tendencies that existed before. It doesn't level the playing field. It tilts it further. https://newsletter.pragmaticengineer.com/p/the-impact-of-ai-on-software-engineers-2026

LINKEDIN

We just got results from a survey of 900+ software engineers on how they use AI tools. The findings reveal something uncomfortable: the AI revolution in software development is far more uneven than anyone wants to admit. Start with costs. Companies are footing the bill for most AI tool usage, typically paying $100-200/month per engineer for Max plans from Claude Code, Cursor, and similar tools. But finance teams are getting nervous. Several respondents report that their companies have unsustainable AI-tooling budgets right now. The message to engineers: don't worry about price while we figure this out. But that honeymoon period is ending. Around 30% of engineers hit usage limits regularly. When that happens, they switch tools, upgrade to pricier plans, or adopt API-based pricing. European companies worry more about these costs than US-based ones. UK and EU finance teams push back on spending even $30-50/month per engineer, while US companies are more comfortable investing first and measuring impact later. But the real story isn't the money. It's the uneven impact across three distinct archetypes of engineers. Builders care about quality, good architecture, and following good coding practices. They talk about the craft of software engineering. For them, AI tools excel at larger code changes like refactoring, migrations, and improving test coverage. They love accomplishing quality-of-life tasks that wouldn't be worth the time investment otherwise. But they're also drowning in AI slop from colleagues, spending more time debugging AI-generated bugs, and some report a genuine sense of identity loss now that typing code is no longer the bottleneck. Shippers focus on outcomes for products, features, testing, and experimenting with users. They're the most enthusiastic group about AI tools in the survey. They praise and even hype up the tools because of their personal experiences shipping much faster. They love that AI removes friction from building features and exploring ideas. But they're also adding tech debt faster, and there's a real risk they build the wrong things faster. Coasters are engineers who get work done without much taste or concern for quality. They seem to be coasting along and doing what they're told. With AI, they can uplevel faster and punch above their weight. But they generate massive amounts of AI slop in the process, which frustrates the builders who have to review and clean up after them. The consensus: AI amplifies and multiplies tendencies and patterns that existed before. It doesn't level the playing field. It tilts it further. Senior engineers who already knew what good code looked like gain far more from AI than juniors who are still learning those patterns. One CTO at a sports-tech company shared: "It's hard to keep our CFO supportive about investing in these tools because the productivity benefits have proven difficult to conclusively prove. The point that resonated the most was the loss of value when people hit daily limits: having to stop work immediately. Surprisingly, our CFO is still pushing back, despite getting a lot of value through their own AI usage with spreadsheets." This is the hidden cost no one talks about: the organizational friction, the uneven gains, the identity questions, the mounting slop. The tools are powerful. The impact is real. But it's messier and more complicated than the marketing suggests. https://newsletter.pragmaticengineer.com/p/the-impact-of-ai-on-software-engineers-2026

X / TWITTER

Most teams confuse three types of AI agents. Deterministic workflows automate predictable tasks. Reasoning agents handle ambiguity. Multi-agent systems coordinate domains. Mix them up and waste months. https://www.lennysnewsletter.com/p/not-all-ai-agents-are-created-equal

NOSTR

Three types of AI agents exist, and confusing them kills roadmaps. Deterministic automation agents follow predefined workflows with LLMs handling content at specific steps. Build these first: 6-week timelines, clear ROI, minimal risk. Reasoning agents (ReAct) decide what to do next based on context. They're for ambiguous requests where the same input triggers different action sequences. 3-month builds, higher cost, real flexibility. Multi-agent networks coordinate specialized agents across domains. Enterprise-scale only, 6+ months, massive compute needs. The pattern: most teams try to build Category 1 problems with Category 2 frameworks, overengineering solutions that add unnecessary complexity. Or they use Category 1 tools for Category 2 problems and watch it break in production. Before you compare effort or impact on any agent idea, answer: what type of agent is this actually proposing? That determines everything else. Architecture isn't just a technical exercise. It's the foundation for smart prioritization. https://www.lennysnewsletter.com/p/not-all-ai-agents-are-created-equal

LINKEDIN

I've been watching teams struggle with the same agent roadmap problem for months. They open an impact-vs-effort matrix, list 5-10 agent initiatives, and try to compare them side by side. It falls apart immediately. One agent takes 6 weeks to build. Another takes 6 months. One costs $500/month to operate. Another could generate a six-figure annual LLM bill. The problem isn't bad planning. It's that they're comparing fundamentally different kinds of systems as if they were the same thing. Before you can decide which agent to build first, you need to answer a more basic question: what type of agent is each idea actually proposing? This determines almost everything that matters for planning: complexity, required skills and infrastructure, timeline, operational cost, and how you measure success. Every agent idea falls into one of three architectural categories. Deterministic automation: you define the entire flow, AI handles content at specific steps. Think n8n workflows with LLM nodes. These are your 6-week projects that ship fast and deliver measurable ROI quickly. This is where most teams should start. Reasoning and acting agents: AI decides what to do next using available tools. Think Cursor, or agents built with LangGraph. These are 3-month initiatives for when higher-value problems require flexibility and dynamic decision-making that workflows alone can't handle. Multi-agent networks: multiple specialized agents coordinate with each other. Think enterprise systems built with ADK or AutoGen. These are 6+ month projects, typically reserved for later stages when multiple teams must coordinate across domains. The breakdown in our recent survey of 900+ software engineers: roughly 60-70% of opportunities are Category 1, 25-30% are Category 2, and 5-10% are genuine Category 3 problems. Here's what happens when you get the category wrong: you either overengineer a simple workflow into a reasoning system that costs 10x more to build and maintain, or you underengineer a complex problem into a brittle workflow that breaks in production. I've seen teams waste months building LangGraph agents for what should have been n8n workflows. I've watched companies try to handle conversational support with deterministic branching and wonder why customers hate it. Before you prioritize your next agent initiative, run this 5-minute triage: can you map the entire process as a flowchart with clear decision points? If yes, it's Category 1. Does the same user request trigger different action sequences based on context? If yes, it's Category 2. Do you need multiple specialized agents coordinating across domains with separate teams? If yes, it's Category 3. Categorization isn't just a technical exercise. It's the foundation for smart prioritization. https://www.lennysnewsletter.com/p/not-all-ai-agents-are-created-equal