rmnull

After the introduction of agentic code tools, the development speed has increased rapidly, but i have been struggling to keep up with the verification of these tools, since some of these things "just work"(reminds me of the old joke, "it compiles").

So i wanted to know whether this is a me problem, or others are also going through it and what your workflow for this looks like. but mostly I'm interested in the way you approach the work and the thought process behind that.

========

P.S: I'll leave the approaches i have tried before()

* always verify the work and only then approve. But this always leads me to a cognitive load and fried brain state at the end of the day. As a side effect producing poor quality work. And to resolve that i started approaching the work more slowly. This has brought down the development speed a lot but this has been good for my mental health.

* Other thing that i have been meaning to try is to get the development things done quickly, then spend another 1 or two days verifying things. This leads to continous iteration that i want and get the insights that only come after building.

* Other option i have also tried is, write tests and then refine ask it to generate code till those tests work, again the initial barrier entry becomes high, because there's so much of cases to be specified and generated and verified(this is the most reliable approach and happy path I've gotten till now that gives some sense of guarantee about whatever is built). Sometimes gain with agentic tools this initial verification has to be laid out clearly which consumes time and sometimes makes me wanna curse at AI because it misses out on somethings that i said(or i thought was clear with the spec)

Hi HN,

I had to put some prototype together in python and I just find it hard to work with it now. Python is something I used to regularly write and then ship code asap, now all the various scenarios where it can fail just runs in my head and I end up implementing multiple strict checks in places and even then I'm just bothered about future changes breaking these things. I'm skeptical and I have to go and write a lot of tests so that thins don't break and some of them are just silly tests like checking value is in the correct domain. I don't mean to particularly bash on python. Since its not Python's fault. Same goes for JS, I can no longer write plain JS now. I just reach for TS. This is partly due to the fact that I was working on typed code(TS[0] and Java[1]) for last few months. And some of the code in there required correctness guarantees, and it was just easier to reach out for typed language since I get many of the checks for free. However after going there, I find it hard to come back to writing dynamic languages now. Once I've realized that typed languages allow me to restrict my domain and the guarantee that this function can just bother about this restricted domain. I worry free write my code and the tests. I get some sense of confidence in what I'm building. This obsession with staticly typed language has been making me unproductive. And I can't find myself going back to it, even for something like scheme which I love so much I just can't find myself going back to it.

# Footnotes [^0]: Strongly typed TS, no any, and for dynamic values, used to use unknown parse into a known type and then continue with that. Ye there are some downsides here too, for e.g: I was not able to maintain few guarantees here like : if I take X = XS[0], there is no way for typescript to guarantee that X is a value is that is guaranteed to be contained in XS.

[^1]: Yea, Java type system is not the best, I have to use hacks like inheritance to make somethings work, anyway its better than no type system, especially I hate that java allows null which is a major source of annoyance for me and i keep wrapping values in that Optional monad.

==========

TLDR: How do you manage to code in dynamic languages after being exposed to static typing.

What are the ideas in programming that once you saw you could never go back looking into other programs the same way. For e.g, one a recent HN thread about units[0] one user shared a F# snippet like this

    unit type Meters = m
    unit type Seconds = s
    val speed = 5.4 m/s 

I'm unfamiliar with F# but having units right next to value is something i'll be remembering everyday from now on[1]

Some other ideas that changed the way i look at programs.

* Lisp Macros

* First class functions. Passing functions as a value is something that i do everyday.

* Garbage collection. Not having to worry about memory allocation is such a relief.

The last 2 points are surprisingly a common pattern now, but for someone coming from C[2] and shell scripting its a whole different world here.

======

[0]: https://news.ycombinator.com/item?id=30749134

[1]: In school we were made to write units next to values, Now that ive seen it, i ask myself why don't more languages support this.

[2]: i'm aware of function pointers in C but its something that i rarely used(iirc qsort expected it).