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

[Jussi Lahtinen <jussi.lahtinen@xxxxxxxxx>]

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