[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

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
    >
    ---------------------------------------------------------------------------------------
    >