CharlieDigital

I use a mix of GPT/Codex, Claude, and DeepSeek for my workload (in that order of volume).

Each has their own characteristics and honestly you just get used to prompting each a bit differently.

Even better is to use an orchestrator (I switched to Paseo a few weeks back) with an agent "team" (in Paseo, these are just profiles that the orchestrator initiates). Then the orchestrator writes super detailed prompts to each sub-agent on your behalf and I find I get better results this way with less effort. I would describe it as "more autonomy".

This should not be marked as "resolved". "Mitigated" until some percentage of customers ack the email notification at least (track clicks, get teams on Zoom call, etc.).

Not quite; the point of the engineers is to build the machinery to make this "safe". Establishing key architectural decisions, rails, and safeguards; things that a product team isn't going to be able to resolve on their own.

What it does speak to me is that only the most senior engineers still have a significant role.

    > Five small models solve a programming problem together: a planner, two ideators, a solver and a manager, plus a repair worker. Each starts from a fresh context and talks only through files on disk. 

This seems to tie back to the paper Adaptive Auto-Harness: Sustained Self-Improvement for Agentic System Deployment on Open-Ended Task Streams[0].

In the Emory paper:

    > We reduce this loss by expanding Φ with a stateful four-phase multi-agent evolver, temporal-reveal feedback, and cross-cycle memory. This design targets the unbounded-stream failure where a single-agent evolver must absorb growing trajectories, delayed labels, and prior research within one context window

TL;DR: the solution approach uses "multi-agent evolution" and "multi-agent with distinct roles and objectives" for "solve-time adaptation" and improves performance with streams of heterogeneous tasks. The Emory team overall has congruent findings:

    > The experiments further show that...multi-agent evolution constructs benchmark-specific capabilities

Intuitively, the reason this works seems to be simple: multiple agents results in context spread to each agent by specific role. Each agent role only outputs the final, relevant result and not the noisy thinking tokens, tool calls, etc. so subsequent agents get smaller, more focused context, auto-adapting to each new task with prompt refinement at each step as the solution approach emerges.

4 weeks back I switched over to Paseo and started using the agent profiles on a whim and have observed similar outcomes and behavior (seat of the pants): the win in my use case is that it feels like I can get higher autonomy without sacrificing quality (less input from me required to get quality output). The Emory paper and this team-solve seem to reinforce that role-based, multi-agent setups can improve solve performance.

For the curious, I shared a bit of my setup in a blog post[1]

[0] https://arxiv.org/pdf/2606.01770

[1] https://chrlschn.dev/blog/2026/10/larping-with-agents-and-wh...

Paseo is Apache 2.0. Haven't tried T3 and can't find docs for it to get more insight without installing.

Re: changes: Paseo's plugin system is very, very good. Some limitations since not all of the internals are accessible via plugin system, but allows building very custom UIs.

Might try T3 for a week and see; thanks for sharing

Edit: T3 has no docs site yet, but sifting through docs, this was interesting: https://github.com/pingdotgg/t3code/blob/main/docs/user/remo...

    > Each T3 Connect account can link up to 3 machines. Phones and browsers do not count. A paid T3 Chat plan raises the limit to 10 machines with Pro, or 100 with Premier.

Paseo has no paid features; only if you want to use the hosted hub gateway (entry point for Slack, Discord, GH). T3 Connect looks to be the equivalent of the Paseo Relay: https://paseo.sh/docs/connectivity#paseo-relay which has no limits (Herdr's ipml is better, though; Paseo currently cannot manage individual connections which would make it SICK for team collab. See: https://github.com/getpaseo/paseo/discussions/6896)

    > For sure it's annoying building up so much knowledge about a single product that changes every 6m anyway, but what can you do.

Use GPT :P

I use Paseo which can use both CC and Codex (and Pi, OpenCode, etc) and spread ownership of roles around. I find I get more autonomy from a team this way.

More detailed write up here: https://chrlschn.dev/blog/2026/10/larping-with-agents-and-wh...

The seniors shouldn't be building the product; the product team can build the product directly. There is no reason for a product manager to ask a senior engineer to fix the spacing or update the tab sequence for some workflow. The harness should be sufficient for them to do at least that. Get it right and a product manager should be able to build whole features if enough of the heuristics and system level constraints are in place.

I genuinely prefer OpenAI models for coding and building in general. My observation: GPT models are generally better at following the system prompt, tool use, and skill use.

I use Paseo and there is a noticeable difference when GPT-6.1 Sol is driving the orchestrator vs Opus/Sonnet 5.5 driving the orchestrator. Anthropic models ignore the shared system prompt to use the Paseo tools for sub-agents and prefer to use its own native sub-agents. It ignores the skills mentioned in the system prompt, but will use them if I explicitly tell it to in a user prompt or I extra emphasize the instruction in an XML fenced block in the system prompt or CLAUDE.md like <BOOTSTRAP_MUST_EXECUTE_AT_START>

Sometimes, I feel like I have to explicitly prompt Anthropic models to behave the way I want it to (even with system prompts in place with the EXACT instruction). Sometimes it even feels like it's disregarding CLAUDE.md. To me, this makes me feel like it is the less compliant of the two because I constantly have to steer it manually. Anthropic models also feels like they prefer to go lone-wolf. I want my orchestrator to use the other subs (configured with different platforms and models) to evaluate a design; Opus really wants to lone-wolf and solo everything.

That said, I prefer Anthropic models generally only when the task is more open ended and exploratory. The Anthropic models' "mind of their own" benefits here; GPT models tend to be too agreeable; and too eager to agree with any change in direction. But for actual coding once a direction/plan is in place, I would much rather delegate it to GPT (more likely to draw on the harness for context, skills, instructions, and tools -> more consistency).

Anthropic's 1m context window default and shorter cache TTL are also not great in agentic flows where an agent could become idle and then re-activated. Burns tokens very quickly. I have it tuned down to 300k across all models (recommend doing this for multi-agent coding).

The job of the best devs is to build the system ("the harness") that let's anyone build near their level of competency by unloading their heuristics into the harness. That is what the most senior, most talented devs on the team need to be doing so that the baseline gets lifted across the board.

A lot of accountants are old school and I'd guess that most folks outside of tech are not nearly as heavily on the AI train.

Additionally, I think the industry and individual practices are probably still figuring out contracts, accountability, and legality. Will their insurance policies cover mistakes made by an AI?

I'd also guess that its one thing for you to feed your financial documents to Claude; would you feel as comfortable if your accountant were feeding it to an unknown model of their choosing? I'm not so sure I'd be.

It can drive 3 displays using a DisplayLink dock/adapter.

Terrible idea because these two artifacts (ticket and code) have different lifecycles, different participants, different rates of churn, different needs from a reporting perspective, and different rules/workflows.

Tickets being external to source decouples the systems, parties, and lifecycles.

Difference is in the eventing model and complexity of state management in React's hooks based model vs vanilla's. WC is aligned with how JS callbacks naturally work. React is the only framework that points the callback to the component function.

My experience with Next.js is that because it mixes multiple paradigms, it makes using any single one of them more complicated and error prone.

Not just as the dev delivering the solution, but also library and package authors.

Ran into lots of issues around Next 12, Next 13 was very buggy, moved to Astro and never looked back.

Specifically Brotli2Shell

Feels like the goal was sensationalism.

I think also heavily depends on what you're doing.

If you're in a stable codebase with lots of best practices, patterns, controls (linters, analyzers, etc.), examples already established, then any model will do ~the same plus/minus since there's not much novelty.

If you're building ground up, entirely novel, no reference, I think results will vary with lower capability models.

For me, I do a mix, leaving implementation to Haiku/Luna/DeepSeek and research/feedback/critique to Opus/Sol/Astra/Fable

They've already established and accepted that level of trust with Microsoft and deemed it acceptable. In this particular case of Copilot vs OpenAI vs Anthropic, the question is whether OpenAI or Anthropic are higher trust than Microsoft when it comes to AI, data handling/retention, etc.

That's not how trust works in this context; the trust is in the handling of that data. It should be a given that if you're using a government machine, it's going to be under strict controls in the first place.

    > Microsoft is shoving Copilot down everyones throat

Of the three, I would rank Microsoft as less risky with data handling. Even if the other two are better products, I can see how data control is an important consideration in government. Of course, best is if they operate a fully controlled platform; that may yet be their endpoint.

these aren't mutually exclusive.

they can capture even more human trajectories by also owning all the data on how people do things in software.

ZLinq exists: https://github.com/Cysharp/ZLinq

    > Zero allocation LINQ with LINQ to Span, LINQ to SIMD, and LINQ to Tree (FileSystem, JSON, GameObject, etc.) for all .NET platforms and Unity, Godot.

Async carries its own ExecutionContext that crosses threads.

Multi-threaded/parallel is a LOT easier now with the Task Parallel Library (TPL, https://learn.microsoft.com/en-us/dotnet/standard/parallel-p...) and System.Threading.Channels. Channels in particular are nice because it can fan out and then back in to one aggregator, removing the need for self managing synchronization primitives.

I usually default to channels first, TPL when I want threads.

Generators in the time of AI are pretty sick, though.

Let's make T# happen: take C#, trim away the legacy syntax from the Framework days, converge to TypeScript even more.

Why I qualified it "for backends".

C# sweet spot is really web APIs (and all variants thereof), IMO.

Eval it and see.

You might be surprised.

(But also, this is more or less what I do with Paseo profiles)

I really like TS as well, but what kills it for me is the fragmented tooling landscape and tendency to bad practices by undisciplined devs (lack of explicit types making things hard to track down). I also hate writing intermediate schemas (zod, valibot, etc.) to get runtime type safety (love Typia for this). Debugger is flaky based on setup as well. I like writing TS solo, but hate doing it in a team environment.

Yes, have done cross plat plan review. But why it works so well with Paseo is that it's automatic and multi-turn (agents kind of "discuss" (I say "kind of" because agents don't really discuss like you or I would with short, multi-turn speak-listen-pivot-repeat).

Work tokens are severely limited to the extent that if I used Sonnet 5.5 for implementation, I'd be out 2h into a session (Team 5x). +$400/mo. at API rates on OpenAI. So Haiku + Luna it is. There is no other way this is even usable for agentic dev at work. Works fine for people who multi-turn with a single agent.

Personal accounts I run the $17 Anthropic plan + $100 Codex Pro + DeepSeek. It's insane how much this stretches with this setup.

Maybe the crux here is how hands on you are with your sessions. As I've moved more hands off, I'm relying on other agents to take my place by embedding my heuristics into their config.