¿Puede la IA hacer tu código?

Supongo que estoy en una misión, una misión para moderar el asombro que la gente parece sentir en relación con la IA.

Como me dedico a la óptica, escribo mucho código, todo tipo de código, y obviamente me interesa pasar el menor tiempo posible haciéndolo.

Antes de añadir el trazado de Zernike usando el pipeline OpenGL a mi propia plataforma, le pedí a ChatGPT que escribiera uno para mí. Eso fue hace 18 meses.
Ni que decir tiene que el resultado me pareció inútil. ¿Por qué? De nuevo, como en mi post anterior, el código parecía bien a distancia, pero en los detalles no tan profundos, era inútil. Te mostraré lo que quiero decir.

Cálculo de los polinomios de Zernike

Al calcular los polinomios de Zernike, es necesario calcular el polinomio radial (que tiene como parámetro la distancia al centro para una coordenada dada por x e y) y el seno o el coseno del ángulo. Entonces, permítanme preguntarles, humanos que no pueden competir con la IA jagernaut, si ya han calculado la distancia (la hipotenusa o un triángulo) usando las coordenadas x e y, ¿cómo proceden para calcular el seno y el coseno del ángulo?

Creo que 100% de los que habéis leído hasta aquí lo hacéis dividiendo la x y la y con la hipotenusa. ¿Qué hace la lo último en IA ¿Qué hace? Toma las coordenadas y calcula el ángulo utilizando la tangente inversa y, como habrás adivinado, utiliza el ángulo para calcular el seno y el coseno.

¿Toda esa energía para qué?

Este fue el resultado que vi hace 18 meses, y 300 GWh (sólo para las GPU, luego añada refrigeración, redes), o 90 días de aprendizaje de refuerzo después y tenemos exactamente el mismo resultado.

Aquí apenas hay una pizca de inteligencia. Sólo una traducción puramente textual de un material de libro de texto a otra forma de texto.

He intentado llamar la atención sobre los rendimientos logarítmicos del rendimiento de la IA frente a la potencia de cálculo. Viendo esto, me quedo con logarítmico en cualquier momento porque lo que veo es ninguna mejora.

Obviamente, le hice la misma pregunta al asombroso DeepSeek, y en realidad (estoy bromeando), el resultado fue aún peor. No por mucho, porque es difícil producir un código peor que este.

Si quieres comprobarlo por ti mismo, aquí tienes mi sugerencia:
¿Puedes escribir un shader OpenGL que genere un mapa de densidad 2D basado en un vector de coeficientes de zernike? El resultado se muestra a continuación.

uniform vec2 resolution;         // Screen resolution
uniform float zernikeCoeffs[15]; // Array of Zernike coefficients (adjust size as needed)
uniform float scale;             // Scaling factor for the density map

// Convert cartesian (x,y) to polar (rho, theta)
vec2 cartesianToPolar(vec2 xy) {
    float rho = length(xy);
    float theta = atan(xy.y, xy.x);
    return vec2(rho, theta);
}

// Zernike radial polynomial function
float radialPoly(int n, int m, float rho) {
    float result = 0.0;
    m = abs(m);
    
    if ((n - m) % 2 != 0) return 0.0;
    
    for (int k = 0; k <= (n - m) / 2; k++) {
        float coef = 1.0;
        // Calculate binomial coefficient
        for (int i = 1; i <= k; i++) {
            coef *= float(n - 2 * k + i) / float(i);
        }
        for (int i = 1; i <= (n - m) / 2 - k; i++) {
            coef *= float(m + i) / float(i);
        }
        result += pow(-1.0, float(k)) * coef * pow(rho, float(n - 2 * k));
    }
    return result;
}

// Zernike polynomial evaluation
float zernike(int index, vec2 polar) {
    float rho = polar.x;
    float theta = polar.y;
    
    // Zernike polynomial ordering (n,m): (0,0), (1,-1), (1,1), (2,-2), (2,0), etc.
    int n, m;
    if (index == 0) { n = 0; m = 0; }    // Z0,0
    else if (index == 1) { n = 1; m = -1; } // Z1,-1
    else if (index == 2) { n = 1; m = 1; }  // Z1,1
    else if (index == 3) { n = 2; m = -2; } // Z2,-2
    else if (index == 4) { n = 2; m = 0; }  // Z2,0
    else if (index == 5) { n = 2; m = 2; }  // Z2,2
    else if (index == 6) { n = 3; m = -3; } // Z3,-3
    else if (index == 7) { n = 3; m = -1; } // Z3,-1
    else if (index == 8) { n = 3; m = 1; }  // Z3,1
    else if (index == 9) { n = 3; m = 3; }  // Z3,3
    else return 0.0;

    if (rho > 1.0) return 0.0;  // Zernike defined only within unit disk
    
    float radial = radialPoly(n, m, rho);
    if (m < 0) return radial * sin(float(-m) * theta);
    else return radial * cos(float(m) * theta);
}

void main() {
    // Normalize coordinates to [-1, 1] range centered at (0,0)
    vec2 uv = (gl_FragCoord.xy - resolution.xy * 0.5) / (resolution.y * 0.5);
    vec2 polar = cartesianToPolar(uv);
    
    // Calculate wavefront aberration by summing Zernike terms
    float density = 0.0;
    for (int i = 0; i < 15; i++) {
        density += zernikeCoeffs[i] * zernike(i, polar);
    }
    
    // Scale and convert to visible range
    density *= scale;
    float value = (density + 1.0) * 0.5; // Map [-1,1] to [0,1]
    value = clamp(value, 0.0, 1.0);
    
    // Output as grayscale density map
    FragColor = vec4(vec3(value), 1.0);
}