[Date Prev][Date Next][Thread Prev][Thread Next][Date Index][Thread Index]

Re: Claude code analyzed the donut script from a while back 44 frames per second to 100 frames per second

Well, let's take that Adobe suit that was totally rewritten for free with vibecoding. I'm not asking "is it as good", I never did it with OpenSource. I always asked if it's good enough. List hear it from someone who actually uses the original: https://www.youtube.com/watch?v=3PbdkXLnK74
Then let's check the legal side of the question: https://www.youtube.com/watch?v=MKzoSkOm7N0
Now let's look at what it actually does to Adobe's stock: https://www.google.com/search?q=is+adobe+stock+struggling+because+of+ai+clones%3F&sca_esv=f0f7d3a8a529a5b8&sxsrf=AKL5yDjl9aBvkAYtv9JydaCQ1B26cfKItw%3A1793794858407&ei=KiPrauGJGIiL7NYP85n32As&biw=1920&bih=933&uact=5&oq=is+adobe+stock+struggling+because+of+ai+clones%3F&gs_lp=Egxnd3Mtd2l6LXNlcnAiL2lzIGFkb2JlIHN0b2NrIHN0cnVnZ2xpbmcgYmVjYXVzZSBvZiBhaSBjbG9uZXM_MgUQIRigATIFECEYoAEyBRAhGKABSPihAVCsDFjWnwFwBngBkAEAmAGnAqAB_FiqAQcwLjExLjQxuAEDyAEA-AEBmAI6oAL1Z8ICChAAGEcY1gQYsAPCAg0QABiABBiKBRhDGLADwgITEC4YgAQYigUYQxjHARjRAxiwA8ICDRAjGKIHGJ4GGPAFGCfCAg0QIxjwBRieBhiiBxgnwgIEECMYJ8ICChAAGIAEGIoFGEPCAhAQABiABBiKBRhDGLEDGIMBwgIKEC4YgAQYigUYQ8ICEBAuGIAEGIoFGEMYxwEY0QPCAhMQLhiABBiKBRhDGLEDGMcBGNEDwgIIEC4YgAQYsQPCAgsQABiABBixAxiDAcICCBAAGIAEGLQHwgIOEAAYgAQYigUYsQMYgwHCAgUQABiABMICBRAuGIAEwgILEAAYgAQYywEYtAfCAggQABiABBjLAcICBxAAGIAEGA3CAgoQABiABBgNGLQHwgIGEAAYFhgewgIFEAAY7wXCAggQABiABBiiBMICBBAhGBXCAgcQIRgKGKABwgIFECEYnwWYAwCIBgGQBgqSBwg2LjEuNDkuMqAHuqcCsgcIMC4xLjQ5LjK4B8BmwgcEMy01OMgH7QSACAE&sclient=gws-wiz-serp
The point is: it happened. Werther you like it or not, it happened, programming was replaced with prompting. 

04.11.2026 18:34, Jussi Lahtinen пишет:
Just tried it again with chatGPT, now everything works fine. Maybe more time has passed than I remember. They have advanced quite a much. Still I'm bit suspicious about current AIs making big projects. Do those clones really work that well? So far I haven't heard much good about them. 

Jussi
On Wed, Nov 4, 2026 at 1:18 PM Jussi Lahtinen <jussi.lahtinen@xxxxxxxxx> wrote: 

    Bit over a year ago I tried a few different AIs (cannot remember
    which, but at least chatGPT and Deepseek) to write me some code
    and they all failed to produce anything that runs.
    Photoshop replaced with vibecoded version? Have you tried it
    yourself, does it really work?

    Jussi

    On Wed, Nov 4, 2026 at 2:40 AM Admin <admin@xxxxxxxxxx> wrote:

        As of today I'd say if it's not explicitly said something is
        written without Cloude, it's written with it. There is no
        reason to highlight it. No reason to not use it since
        everybody does for a long time. I don't think any Adobe or
        Microsoft project is written with any human effort whatsoever,
        for example. The last Apple Iphone is purely and officially
        AI-designed (but it's a bad example alright). I'm kinda
        surprised it's not obvious to everyone. Programming is a
        hobby. Commercial programming is done by AI, otherwise you
        will be very slow and make a lot of mistakes. A lot of my
        friends are making commercial games. They don't know how to
        program, never were into that. But since you don't need to be
        a programmer to make software anymore, they all do, and sell
        it quite successfully. Only thing I don't understand is who
        buys it, when you can create your own for free. People already
        replaced Photoshop without knowing how to program. I can see
        why project like Debian are calling meetings to discuss
        weather they will pass the AI-code or they wouldn't. Because
        of course naturally the code in Linux will be written by AI
        just like any other code nowadays, and if they don't want that
        they have to say it out loud, because by default any code
        today is AI-written. Concerning "write better code then us",
        well, AI cant invent anything, AI writes basically only what
        was already written before. It's just faster, cheaper and
        anybody can have a "programmer" in their team. Vibecoding has
        won years ago, look around closely.

        Dmitry.

        04.11.2026 03:04, Jussi Lahtinen пишет:

        I still have not seen any successful big project made by AI
        alone. Maybe they exist and I'm not just aware of them, but
        until I see that I'm not convinced they "write better code
        than us".



        Jussi

        On Tue, Nov 3, 2026 at 3:10 PM Admin <admin@xxxxxxxxxx> wrote:

            Well, what did you expect?
            Claude writes better code then us, so that's why many
            programmers are
            not writing any code anymore, for a long time now,
            worldwide. That's
            what AI was made for.
            So, what's your point?

            Dmitry.

            03.11.2026 06:38, Brian G пишет:
            > I just handed an old piece of code over to Claude code,
            asked it to
            > analyze the code and it did, without my intervention at
            all, it
            > produced and tested the updated code. This script code
            draws a 3d
            > donut on the screen, and then animates it in a way that
            makes it
            > appear to spin.
            >
            > In the original code, frame rate was about 44fps, the
            ctrl-c did not
            > work all the time, a lot of time was spend creating the
            output strings.
            >
            > Claude re-wrote the script with zero input from me, the
            script now
            > churns at a nice 100fps and ctrl-c always causes it to
            stop... ummm.
            > And as a bonus, you can now resize the terminal on the
            fly and the
            > code resizes the donut...new feature..
            > I am impressed/scratching my head/thoughtful....
            >
            > script code written by claude is attached.
            >
            >
            ___________________________________________________________________cut

            >
            here______________________________________________________________________
            >
            > #!/usr/bin/env gbs3
            > ' Gambas Script File Created 01/10/2021 20:11:31.237
            > ' Original Donut program by Andy Sloane
            > ' https://www.a1k0n.net/2011/07/20/donut-math.html
            > '
            > ' Usage:  ./donutSpiner       Press Ctrl-C to stop.
            > '
            > ' Changes from donutSpinner: by claude
            > '  - runs under gbs3
            > '  - has a Main, so the program actually starts
            > '  - Ctrl-C / SIGTERM / SIGHUP set a flag; the loop
            ends and the
            > cursor and
            > '    screen are restored (the original left the cursor
            hidden)
            > '  - no debug output (Hello world, linetrace)
            > '  - errors are not swallowed in render_frame; they end
            the program
            > with a message
            > '  - frame is built in one Byte[] (rows + newlines) and
            printed with
            > one ToString()
            > '  - output and z buffers are allocated once and
            cleared with Fill()
            > each frame
            > '  - points that project off screen are skipped instead
            of piling up
            > on the border
            > '  - terminal resize is detected each frame and the
            buffers are rebuilt
            >
            > Fast Unsafe
            > Use "gb.signal"
            >
            > Const theta_spacing As Float = 0.01
            > Const phi_spacing As Float = 0.01
            > Const TwoPi As Float = 6.28
            >
            > Const R1 As Float = 1.00
            > Const R2 As Float = 2.00
            > Const K2 As Float = 5.0
            > Const ShadeSource As String = " .,-~:;=!*$#@"
            >
            > Private Shader As Byte[]
            > Private ShadeMax As Integer
            >
            > Private screen_width As Integer     ' columns
            > Private screen_height As Integer    ' rows used by the
            donut (last row
            > is the status line)
            > Private K1 As Float
            > Private bOutput As Byte[]           ' (screen_width + 1) *
            > screen_height, includes a newline per row
            > Private zBuffer As Float[]          ' screen_width *
            screen_height
            >
            > Private bQuit As Boolean
            >
            > Public Sub Main()
            >
            >   Dim a, b As Float
            >   Dim fFrameStart, fFrameTime, fRateStart, fElapsed,
            fFrameRate As Float
            >   Dim iFrames As Integer
            >   Dim sTime, sRate As String
            >
            >   Signal[Signal.SIGINT].Catch
            >   Signal[Signal.SIGTERM].Catch
            >   Signal[Signal.SIGHUP].Catch
            >
            >   Shader = Byte[].FromString(ShadeSource)
            >   ShadeMax = Shader.Max
            >
            >   Print "\e[2J";
            >   fRateStart = Timer
            >
            >   While Not bQuit
            >     CheckScreenSize()
            >
            >     fFrameStart = Timer
            >     render_frame(a, b)
            >     fFrameTime = Timer - fFrameStart
            >
            >     a += 0.07
            >     b += 0.03
            >
            >     Inc iFrames
            >     fElapsed = Timer - fRateStart
            >     If fElapsed >= 1.0 Then
            >       fFrameRate = iFrames / fElapsed
            >       iFrames = 0
            >       fRateStart = Timer
            >     Endif
            >
            >     sTime = Format(fFrameTime, "0.0000")
            >     sRate = Format(fFrameRate, "0.0")
            >     Print sTime; "s  "; sRate; " fps\e[K";
            >     Flush
            >
            >     Wait 0   ' signals are delivered here
            >   Wend
            >
            > Finally
            >   ' Show the cursor again, clear the screen and home
            the cursor
            >   Print "\e[?25h\e[2J\e[H";
            >   Flush
            >
            > Catch
            >   Error "donutSpiner error:";; Error.Text;; "at";;
            Error.Where
            >   Quit 1
            >
            > End
            >
            > '' Called by gb.signal for the signals caught in Main
            > Public Sub Application_Signal(iSignal As Integer)
            >
            >   bQuit = True
            >
            > End
            >
            > '' Read the terminal size and (re)build the buffers if
            it changed
            > Private Sub CheckScreenSize()
            >
            >   Dim w As Integer = File.Out.Term.Width
            >   Dim h As Integer = File.Out.Term.Height - 1   ' keep
            the last row
            > for the status line
            >
            >   If w < 2 Then w = 2
            >   If h < 2 Then h = 2
            >   If w = screen_width And If h = screen_height Then Return
            >
            >   screen_width = w
            >   screen_height = h
            >
            >   ' K1 scales the projection to the screen width. With
            the divisor 9
            > the torus
            >   ' edge (x = R1 + R2, z = 0) lands at screen_width / 9
            from the
            > center; the
            >   ' parts closest to the viewer project further out.
            Increase the
            > divisor to
            >   ' make the donut smaller, decrease it to make it bigger.
            >   K1 = screen_width * K2 / (9.00 * (R1 + R2))
            >
            >   bOutput = New Byte[(screen_width + 1) * screen_height]
            >   zBuffer = New Float[screen_width * screen_height]
            >   Print "\e[2J";
            >
            > End
            >
            > Public Sub render_frame(a As Float, b As Float)
            >
            >   Dim cosA As Float = Cos(a)
            >   Dim sinA As Float = Sin(a)
            >   Dim cosB As Float = Cos(b)
            >   Dim sinB As Float = Sin(b)
            >   Dim stride As Integer = screen_width + 1
            >   Dim halfW As Float = screen_width / 2.00
            >   Dim halfH As Float = screen_height / 2.00
            >   Dim theta, phi As Float
            >   Dim costheta, sintheta, theta1, theta2, theta3,
            theta4, theta5,
            > circlex, circley As Float
            >   Dim cosphi, sinphi, L, x, y, z, ooz As Float
            >   Dim xp, yp, iShade, j As Integer
            >
            >   ' Clear the buffers and put a newline at the end of
            every row
            >   bOutput.Fill(32)
            >   zBuffer.Fill(0)
            >   For j = 1 To screen_height
            >     bOutput[j * stride - 1] = 10
            >   Next
            >
            >   For theta = 0.00 To TwoPi Step theta_spacing
            >     costheta = Cos(theta)
            >     sintheta = Sin(theta)
            >     theta1 = sinA * sintheta
            >     theta2 = costheta * sinB
            >     theta3 = cosA * costheta
            >     theta4 = cosA * sintheta
            >     theta5 = costheta * sinA
            >     circlex = R2 + (R1 * costheta)
            >     circley = R1 * sintheta
            >
            >     For phi = 0.00 To TwoPi Step phi_spacing
            >       cosphi = Cos(phi)
            >       sinphi = Sin(phi)
            >
            >       ' Luminance, ranges from -sqrt(2) to +sqrt(2). If
            it's <= 0 the
            > surface
            >       ' is pointing away from us, so we won't bother
            trying to plot it.
            >       L = (cosphi * theta2) - (theta3 * sinphi) -
            theta1 + (cosB *
            > (theta4 - (theta5 * sinphi)))
            >       If L <= 0 Then Continue
            >
            >       x = circlex * (cosB * cosphi + sinA * sinB *
            sinphi) - (circley
            > * cosA * sinB)
            >       y = circlex * (sinB * cosphi - sinA * cosB *
            sinphi) + (circley
            > * cosA * cosB)
            >       z = K2 + cosA * circlex * sinphi + circley * sinA
            >       ooz = 1.00 / z
            >
            >       ' x and y projection. y is negated because y goes
            up in 3D space
            >       ' but down on 2D displays.
            >       xp = CInt(halfW + K1 * ooz * x)
            >       yp = CInt(halfH - K1 * ooz * y)
            >
            >       ' Skip points that fall off screen (Unsafe: no
            array bounds
            > checking here)
            >       If xp < 0 Or If xp >= screen_width Then Continue
            >       If yp < 0 Or If yp >= screen_height Then Continue
            >
            >       If ooz > zBuffer[yp * screen_width + xp] Then
            >         zBuffer[yp * screen_width + xp] = ooz
            >         iShade = 1 + CInt(L * 8)
            >         If iShade > ShadeMax Then iShade = ShadeMax
            >         bOutput[yp * stride + xp] = Shader[iShade]
            >       Endif
            >     Next
            >   Next
            >
            >   ' Hide the cursor while drawing, home it and print
            the whole frame
            > at once.
            >   ' The last byte of the buffer is a newline, which
            moves us to the
            > status line.
            >   Print "\e[?25l\e[H"; bOutput.ToString();
            >
            > End
            >
            ------------------------------------------------------------------------------------------------cut

            > here
            >
            ---------------------------------------------------------------------------------------
            >