Andrei

/ Prompt/context/harness engineer

[Emil Kowalski @emilkowalski]

Here are a few example prompts that go well with the /find-animation-opportunities skill:

Scoped to one view with extra context for more accurate judgement:
“Find animation opportunities in the checkout flow. It’s used a few times per session by each customer, factor this in.”

Combined with the /improve-animations skill, this works extremely well:
“Look through the dashboard UI for places that would benefit from motion, tell me what you'd skip and why, then turn the top suggestion into an improve-animations plan.”

Using this as a “shield” instead of trying to find ways to add animations:
“Before we add any motion to this dashboard, is there anything here that should animate at all?”

Right after an agent builds new UI:
“I just generated this settings page and it has zero motion. What should animate and what shouldn’t?”

[Tibo @thsottiaux]

If you aren't yet bold enough to install the Codex app, you can stay in the presence of your orange crab and point it at GPT 5.6 Sol. Takes 5 minutes. Kudos to Theo for explaining one of the ways to get this done.

Step 1: Install CLIProxyAPI
Step 2: Connect
Step 3: Define following alias and enjoy claudex

```
alias claudex='CLAUDE_CODE_SUBAGENT_MODEL=gpt-5.6-sol \
CLAUDE_CODE_ALWAYS_ENABLE_EFFORT=1 \
CLAUDE_CODE_MAX_TOOL_USE_CONCURRENCY=3 \
ENABLE_TOOL_SEARCH=false \
claude --model gpt-5.6-sol'
```

If this gets blocked, I owe you a reset.

[Praveen Neppalli @praveenTweets]

Agentic AI adoption is on fire at @Uber, and it's changing the way we build, not just in engineering, but across the entire company.

Today, 99% of our engineers use AI tools. More than 70% of pull requests are attributed to local or cloud agents. And our engineers have built 2,500+ agent skills across the software development lifecycle.
Those numbers are exciting, but they led us to a much bigger question:

How do we bring agentic AI beyond engineering?

Finance. Legal. Operations. Marketing. Customer Support. HR. Procurement.

These functions run on complex workflows that are often manual, highly nuanced, and spread across dozens of systems. You can't automate them effectively by looking at process diagrams or documentation. You have to understand how the work actually gets done.

So we created something called Agentic Pods.

The idea is simple.

We handpicked ~30 of our most AI-proficient engineers (people with deep knowledge of Uber's systems) and paired each of them with a domain expert from a business function.

Then we gave every pod just two weeks.
• Days 1 – 2: Shadow the expert. Observe every step. Document workflows. Ask questions. Build intuition.
• Day 3: Prioritize opportunities based on scale, repetition, business impact, and data availability.
• Days 4 – 5: Build a working agent alongside the person doing the job.
• Days 6 – 9: Validate with several others performing the same work. Does it generalize? Does it actually make their job better?
• Day 10: Ship.

In just the past two months, we've run 16 Agentic Pods across 16 different business functions.
• Capital allocation across 150 cities: 15 hours → 30 minutes.
• Financial pacing reports: 2 days → 10 minutes.
• Marketing web quality assurance: 2 weeks → 50 minutes.
• Support workflow creation: 9,000 manual workflows → self-service automation.

The productivity gains are impressive, but what surprised us most wasn't the speed.
• It was how quickly engineers embedded in unfamiliar domains uncovered opportunities that had been hiding in plain sight.
• The biggest wins rarely come from automating one task. They come from rethinking an entire workflow. Once you redesign the workflow around AI, you often eliminate handoffs, remove unnecessary approvals, replace legacy tooling, reduce vendor spend, and dramatically accelerate decision-making.
• The workflow becomes the unit of automation - not the individual task.
• The most impactful agent skills cut across teams, orgs, functions, tools, and systems.

The biggest lesson? The best AI opportunities are rarely visible from the outside.

You discover them by sitting next to the people doing the work, understanding every friction point, and building with them, not for them.

We're now forming a dedicated team to scale this further and go deeper. They'll deeply understand the work, redesign it from the ground up, and use AI to fundamentally change how the business operates.

It's exciting times!

[Tibo @thsottiaux]

Reminder that you can use the Codex App, CLI and SDK with any open source model, not just with OpenAI models.

https://t.co/spPifB4ck3

[Phil Chen @philhchen]

https://t.co/oMoEAYkqGl

[Thariq @trq212]

https://t.co/hPiZr1kG7r

[Mitchell Hashimoto @mitchellh]

https://t.co/hXE5lXLpFT

[George Grigorev @iamgrigorev]

https://t.co/Mny7zow50b

[Jason Zhou @jasonzhou1993]

https://t.co/Y6K8lC6hik

[Harvey @harvey]

https://t.co/hlb6DJ8zbV

[SCOTTY BEAM @ScottyBeamIO]

https://t.co/rua4N4akAh

[Zach Lloyd @zachlloydtweets]

https://t.co/NM8obyrq7w

[PostHog @posthog]

https://t.co/JdT9SeLxbZ

[Anatoli Kopadze @AnatoliKopadze]

Head of Engineering Shopify:

"AI writes the code, AI reviews the code. Your job is just to write the loops around it."

26 minutes on how AI changed the way 3,000 engineers work inside a single company.

Ignoring it while everyone else uses AI to do more is the fastest way to fall behind.

Watch it, then read the step by step guide on loops below.

[Greg Brockman @gdb]

Agents are being adopted very quickly and accelerating work. How this looks across OpenAI itself:

[Alisa Liu @alisawuffles]

I'm joining OpenAI next week!🥹 The job search turned out to be really challenging but also super rewarding, so I wrote a small blog to share what I learned along the way and hopefully make the process a little less mysterious for the next person. https://t.co/6FigSBdenD

[Thariq @trq212]

https://t.co/R6exTuF7P8

[Suraj Sharma @suraj_sharma14]

If I had 6 months to become an Agentic AI Engineer.

I'd do this.

Stage 1: Python + Async Foundations
asyncio, FastAPI, event-driven architecture, error handling, API integration patterns.

Stage 2: LLM Fundamentals for Agents
Context management, model routing, token economics, latency tradeoffs, failure modes.

Stage 3: Tool Calling + Structured Outputs
Pydantic validation, function calling schemas, error recovery, dynamic tool discovery.

Stage 4: Memory + State Management
Short-term buffers, long-term vector recall, context compression, cross-session sync.

Stage 5: Single Agent Workflows
ReAct loops, plan-and-execute, self-reflection, iteration limits, graceful degradation.

Stage 6: Multi-Agent Orchestration
LangGraph/CrewAI, supervisor patterns, message passing, conflict resolution, handoffs.

Stage 7: Human-in-the-Loop Systems
Uncertainty detection, approval gates, audit trails, resume logic, intervention points.

Stage 8: Evaluation + Quality Assurance
Automated eval harnesses, LLM-as-a-judge, regression testing, hallucination metrics.

Stage 9: Observability + Tracing
Distributed tracing (LangSmith/Arize), cost dashboards, latency monitoring, alerting.

Stage 10: Security + Guardrails
Prompt injection defense, output filtering, PII redaction, sandboxed execution, compliance.

Stage 11: Production Deployment
vLLM/SGLang, Kubernetes scaling, CI/CD for agents, canary releases, rollback strategies.

Stage 12: Open Source + Portfolio
Ship autonomous agents publicly, write architecture docs, record demos, contribute to libs.

Most people stay stuck watching tutorials.

Builders get hired.

(Bookmark it)

[Satya Nadella @satyanadella]

https://t.co/vLmiBKTtX3

[Dan Shipper @danshipper]

codex power-user best practices:

- a few different "pulse" threads that run every morning to check the status of stuff i care about, e.g. proof metrics, all company meetings, etc

- a "log" thread for ongoing, everyday activity i want to track. for me that's my "writing log"—want to track what im writing about, and working on from piece to piece

- "inbox" thread which gathers all of my emails right now, but eventually will pull in all of the main important things from each "pulse" thread

- "router" thread which knows about all of the other threads, and is also hooked up to my email to push emails into each thread appropriately