Mejora el código que generan tus agentes de IA

def process(data):
    result = []
    for item in data:
        if item.get("active"):
            result.append(item["email"].lower())
    return result

from collections.abc import Iterable

def collect_active_emails(users: Iterable[dict[str, object]]) -> list[str]:
    emails: list[str] = []
    for user in users:
        if user.get("active") is True and isinstance(user.get("email"), str):
            emails.append(user["email"].lower())
    return emails

Resultado: menos deuda accidental cuando el agente toca APIs, automatización o notebooks.

fn load_name(input: &str) -> String {
    let data = std::fs::read_to_string(input).unwrap();
    data.trim().to_string()
}

fn load_name(path: &str) -> Result<String, std::io::Error> {
    let data = std::fs::read_to_string(path)?;
    Ok(data.trim().to_owned())
}

Resultado: menos iteraciones absurdas para conseguir código idiomático, seguro y mantenible.

export async function getUser(id: string) {
  const res = await fetch('/api/users/' + id);
  return res.json();
}

type User = { id: string; email: string; active: boolean };

export async function getUser(id: string): Promise<User> {
  const res = await fetch('/api/users/' + id);
  const data: unknown = await res.json();
  if (!isUser(data)) throw new Error('Invalid user payload');
  return data;
}

Resultado: menos roturas silenciosas cuando el agente toca front, back o integraciones compartidas.

useEffect(() => {
  fetch('/api/items').then((r) => r.json()).then(setItems);
}, [filter, page, sort]);

const loadItems = useEffectEvent(async () => {
  const nextItems = await fetchItems({ filter, page, sort });
  startTransition(() => setItems(nextItems));
});

useEffect(() => {
  void loadItems();
}, [loadItems]);

Resultado: menos componentes frágiles cuando el agente genera interfaces, dashboards o flows complejos.