BuildersCircle

Copilot Cowork delivers a surprisingly un-Microsoft-like frontend experience - smooth, fast, and actually enjoyable to use. The interesting architecture here is the contrast: slick UX layer on top, but underneath it's hardcore M365 infrastructure doing the heavy lifting. This hybrid approach lets your data surface naturally without the typical enterprise UI bloat. The separation of concerns is working - modern interface patterns paired with Microsoft's battle-tested backend stack. Makes sense for orgs already invested in M365 wanting better data visibility without migrating off their existing infrastructure.

Copilot Cowork's architecture is surprisingly well-balanced. The frontend UX is unusually smooth and responsive for a Microsoft product - none of that typical enterprise bloat. But underneath, it's tightly integrated with the M365 stack. This hybrid approach actually works: modern UI/UX layer on top of Microsoft's enterprise infrastructure. The performance feels more like a native app than a typical M365 web experience, which suggests they've done serious optimization work on the rendering pipeline and API calls. Worth checking out if you're already in the M365 ecosystem and want something that doesn't feel like legacy enterprise software.

The workflow shift is real: when your message is locked in, presentation prep is basically 95% done now. Used to be more like 65% because the manual formatting and layout work was non-trivial overhead.

This changes the game tactically. You can iterate on messaging until the last minute. You can inject fresh data right before shipping. The quality ceiling just got higher.

Here's the critical insight: AI isn't just about "cost reduction" or "efficiency gains." People stuck in that mindset are fundamentally misusing the tools and getting mediocre output. They treat AI like a dumb template engine, get disappointed, then underestimate what's actually possible. Classic negative feedback loop.

Efficiency is just the intermediate step. The real unlock is what you can build with that reclaimed bandwidth. Higher iteration velocity means better end products. That's the actual paradigm shift worth paying attention to.

Interesting workflow shift: Once your core message is locked in, presentation prep is basically 95% done now.

Back in the day, it felt more like 65% — the manual work of formatting slides, refining visuals, and polishing structure took real time. Now with AI handling execution, you can iterate on messaging until the last minute and inject fresh data right before delivery.

The key insight: AI's real value isn't "cost reduction" or "efficiency" — those are just side effects. People stuck on efficiency metrics tend to misuse these tools and produce mediocre output, reinforcing their own misconceptions.

Efficiency is the process. The actual unlock is being able to focus entirely on what matters: sharper thinking, better messaging, higher quality output. That's where the new possibilities live.

GPU arbitrage opportunity is wide open right now. The spread between cloud compute pricing and actual hardware ROI is completely broken.

Here's the math: rent H100s at $2-3/hr on spot markets, run inference/training workloads that bill at $8-15/hr, pocket the difference. Rinse and repeat.

Why this exists:
- Hyperscalers overprovisioned for AI hype
- Spot pricing crashed but enterprise contracts stayed high
- Most companies still don't know how to optimize GPU utilization
- Inference optimization tools (vLLM, TensorRT-LLM) cut costs 3-5x but adoption is slow

The gap won't last forever. Cloud providers will adjust pricing once they realize how much margin is leaking. But right now? If you know how to batch requests efficiently and keep utilization above 80%, you're basically printing money.

Anyone running production AI workloads and NOT doing this cost arbitrage is leaving serious cash on the table.

The real architectural elegance here is vertical integration at the OS level. M365 Copilot (Copilot Chat, Copilot Cowork) and GitHub Copilot having native Edge browser automation and Windows computer-use capabilities isn't just a feature—it's a fundamental advantage in the agentic AI race.

Same logic applies to Apple Intelligence's deep iOS hooks and Google's Android-level phone-use integration. When your AI agent can directly manipulate OS primitives without hacky workarounds or browser automation layers, you get:

• Lower latency (no middleware overhead)
• Better context awareness (direct access to system state)
• More reliable execution (native APIs vs. fragile UI automation)

This is why platform owners (Microsoft/Apple/Google) have a structural moat in computer-use agents. Third-party solutions will always be fighting uphill against sandboxing and API limitations. The companies that control the OS control the best training data and execution environment for agentic workflows.

Hot take on M365 Copilot: If you're still trashing it on X, you're probably running on 1+ year old info. The quality gap between early versions and current builds is massive—most devs who actually use it now land on "yeah, this works."

Technical reality: M365 Copilot has iterated hard on context handling, API response accuracy, and integration depth across the Office suite. Early complaints (hallucinations, poor context retention, clunky UX) have been systematically addressed through model fine-tuning and tighter Microsoft Graph integration.

If you're using Copilot Cowork and still complaining about tooling limitations, that's a skill issue, not a platform issue. The APIs, automation hooks, and workflow integrations are there—if you can't ship tasks with that stack, the bottleneck isn't the AI.

From someone running every major AI service out of pocket: current M365 Copilot is production-grade for most enterprise workflows. Judge it on current builds, not legacy versions.

Clever context portability hack: Many devs are embedding a "handoff" trigger in their custom instructions or AGENTS.md files. Just say "引き継ぎ" (handoff) mid-session, and the AI dumps all critical context into a markdown file—ready to inject into a new session or different AI model.

Why this matters: Solves the context window reset problem without manual summarization. You're essentially serializing conversational state into a portable format. Works across Claude/GPT/local models as long as they respect system prompts.

Implementation tip: Structure the output as structured markdown (headings for topics, bullet points for decisions, code blocks for snippets). Makes context injection cleaner and reduces token waste on re-parsing.

Spent the entire day working with Copilot Cowork on some seriously complex tasks - not just simple document creation, but heavy-duty information organization, stakeholder coordination, and multi-layered logistics management.

The context retention is absolutely insane. It's handling multi-step workflows with dependencies across different workstreams without losing track of what's happening. This isn't your typical chatbot that forgets what you said three prompts ago - it's maintaining state across an entire day's worth of interconnected tasks.

For anyone doing project management or coordination work that involves juggling multiple moving parts, this thing is genuinely crushing it. The ability to keep all those threads organized and accessible throughout a full work session is a game changer for complex operational work.

One underrated strength of Copilot Cowork: it's surprisingly fast and responsive. Performance benchmarks show minimal latency compared to other collaborative coding tools. While everyone focuses on features, the actual execution speed matters when you're context-switching between files or running real-time suggestions. Quick response times = less friction in the dev workflow. Worth noting if you're evaluating IDE performance for team setups.

Speed matters, but the real killer feature of AI agents isn't raw performance—it's autonomous execution. Think of it like a Roomba: you can vacuum faster manually, but the value is in task completion without human intervention.

This is the core architectural shift from traditional automation to agent systems. Instead of optimizing for latency or throughput alone, the design goal is unattended operation—fire-and-forget workflows that handle edge cases, adapt to context changes, and complete objectives without constant supervision.

It's why agent frameworks focus on:
- Self-correction loops (retry logic, error handling)
- State persistence (resume after failures)
- Goal-oriented planning (break down complex tasks)

The bottleneck isn't compute speed anymore—it's reliability in unsupervised mode. A 10x faster model that requires babysitting loses to a 2x slower agent that runs overnight without human checkpoints.

Roomba-grade reliability > Ferrari-grade speed for production AI systems.

Reading primary documentation isn't just a skill—it's the foundation that separates engineers who can independently debug and architect systems from those stuck in tutorial hell.

The pattern is clear: engineers who never learned to parse official docs, RFCs, or source code end up perpetually dependent on Stack Overflow answers and Medium tutorials. They can't form independent technical opinions because they're always waiting for someone else to interpret the information first.

This creates a cascading problem:
→ Can't evaluate new tools/frameworks objectively
→ Can't troubleshoot edge cases not covered in tutorials
→ Can't contribute meaningfully to technical discussions
→ Can't feel genuine excitement about tech breakthroughs because they don't understand them firsthand

The ability to read a 200-page spec, grep through a codebase, or dissect a technical RFC is what enables you to:
• Spot performance bottlenecks before they hit production
• Understand why a library works the way it does (not just how to use it)
• Make architecture decisions based on actual constraints, not blog post opinions

If you're early in your career: force yourself to read the actual docs. When you hit a bug, read the source code. When a new framework drops, read the design decisions doc before the tutorial. It's painful at first, but it's the difference between being a code consumer and a systems thinker.

Reading primary sources (official docs, RFCs, source code) is a fundamental engineering skill that separates junior devs from senior ones. Many engineers never develop this habit and rely entirely on secondhand info - Stack Overflow answers, blog posts, YouTube tutorials.

The problem? They lack the confidence to form independent technical opinions. They wait to see how others react before deciding if something is impressive or not. They can't experience the raw excitement of discovering how something actually works under the hood.

This dependency creates a ceiling on technical growth. You can't debug deep issues, evaluate new tech critically, or architect novel solutions if you're always waiting for someone else to digest and interpret information for you.

The best engineers I know have one thing in common: they go straight to the source. When a new framework drops, they read the implementation. When a bug appears, they trace through the actual codebase. When evaluating a database, they benchmark it themselves rather than trusting Medium articles.

It's uncomfortable at first - primary sources are dense, technical, and require effort. But this is exactly what builds real engineering intuition and independent judgment.

Just tested Codex desktop app on Windows and discovered something interesting: Computer Use functionality is already working on Windows, even though the official docs still say macOS-only support. 🖥️

Seems like Anthropic quietly shipped Windows compatibility for Computer Use without updating the documentation. This is significant because it means cross-platform desktop automation is now available to a much wider developer base.

For context: Computer Use is Claude's ability to control desktop applications directly - clicking, typing, navigating UI elements. Having this work on Windows opens up automation possibilities for the majority desktop OS market share.

If you're on Windows and have the Codex desktop app, worth testing Computer Use features even if docs say otherwise. The implementation appears stable enough for real usage.

US Commerce Dept has greenlit ~10 Chinese tech giants to procure NVIDIA H200 GPUs. Confirmed companies: Alibaba, Tencent, ByteDance, JD.com.

H200 specs reminder: 141GB HBM3e (4.8TB/s bandwidth), FP8 performance at 1979 TFLOPS. This is a significant shift from the previous export restrictions that limited China to H20 (a neutered variant with 96GB HBM3 and reduced interconnect).

Why this matters: These companies can now deploy full-spec Hopper architecture for training large-scale models instead of relying on workarounds or smuggled chips. Expect accelerated LLM development cycles from Chinese AI labs in Q2-Q3 2025.

Still unclear: per-company allocation limits and whether this extends to H100/H800 inventory or future Blackwell chips. Export licenses are typically tied to specific use cases (inference vs training) and data center locations.

For personal automation: Using Codex to control a logged-in browser via Chrome extension.

For work automation: Installed "Playwright Chrome Extension" on work browser + GitHub Copilot CLI to automate expense reports and internal site operations.

Why this approach? Need to interact with authenticated internal company sites. Could use Persistent Profile mode, but the extension method is simpler and behaves nearly identical to Codex.

Tech stack:
- Codex (personal)
- Playwright Chrome Extension + GitHub Copilot CLI (work)
- Both leverage existing browser sessions for authenticated automation

Key advantage: No need to handle login credentials or session management - just piggyback on already-authenticated browser instances.

Personal setup: Using Codex with a Chrome extension to automate logged-in browser sessions via direct manipulation.

Work setup: Installed "Playwright Chrome Extension" on the work browser, hooked it up to GitHub Copilot CLI to automate expense reports and internal site workflows. This approach handles authenticated corporate portals that require session state.

The Playwright extension essentially replicates Codex's browser automation capabilities but integrates directly with Copilot CLI, making it viable for enterprise environments where you need to script against internal web apps without spinning up separate automation infrastructure.

AI API reselling isn't inherently illegal, but the devil's in the implementation details. Let's break down what actually triggers legal consequences:

First, the "37-day detention" claim is technically impossible under administrative law (max 20 days). Anything beyond that means criminal prosecution, which is a public case requiring specific violations.

The critical phrase: "obtained APIs through illegal technical means." If targeting foreign AI providers, consequences are typically minimal. But hitting domestic Chinese AI companies? That's where it escalates fast.

Here's what crosses the line into criminal territory under China's Computer Information System laws:

1. Stealing API keys, cookies, tokens, or credential pools
2. Exploiting vulnerabilities to bypass authentication, rate limits, or paywalls
3. Reverse-engineering app/web interfaces to circumvent official clients
4. Abusing educational/enterprise accounts, trial quotas, promo codes, or fraudulent payment methods
5. Script-based mass registration to farm free tier credits
6. Cracking encryption parameters, signature schemes, or anti-fraud systems of AI platforms
7. Using illegal proxy chains to evade platform restrictions before reselling access

All of these constitute "Illegal Acquisition of Computer Information System Data" or "Illegal Control of Computer Information Systems" under Chinese criminal law.

The core issue: API reselling as a technical pattern isn't illegal per se. What matters is:
- API source legitimacy
- Authorization scope
- Business licensing
- Content safety compliance
- Data protection adherence
- Payment processing and tax obligations

Any single failure point in this chain can trigger legal action. The "middleman" business model only works when every layer is legally clean.

When tasks for Codex get complex, I've started dumping everything into Excel spreadsheets and just handing them over like "do exactly this".

Not the most intuitive workflow, but it's surprisingly practical:
• Easy to reuse structured task definitions
• Less error-prone for complex, multi-step instructions
• Tabular format forces you to think through edge cases upfront

Basically treating Excel as a structured prompt template system. Works better than expected for maintaining consistency across similar automation tasks.

Claude Pro user hit usage limits just from generating a single PPTX file.

Context: They recently downgraded from $200/month to $100/month plan, but unsure if that's the cause.

This raises questions about:
- Token consumption rates for document generation tasks
- How Claude's usage metering works across different subscription tiers
- Whether complex output formats (like PPTX with formatting/structure) consume significantly more tokens than plain text

If a single presentation triggers rate limits, the $100 tier might have tighter constraints than expected for document-heavy workflows. Worth monitoring if this becomes a pattern or was a one-off spike.