Code: AI or Humans, vs Humans and AI ?

Ryan Dahl on X: "This has been said a thousand times before, but allow me to add my own voice: the era of humans writing code is over. Disturbing for those of us who identify as SWEs, but no less true. That's not to say SWEs don't have work to do, but writing syntax directly is not it." / X

My take is quite different:

• When computers ware created, simple and slow, humans did write binary/hex code "by hand".
  The result was still worth it, much faster calculations that "by hand".
  Even Microsoft creators did that, current $4T empire is started that way believe or not.
  
  
• When computers become more capable, we invented assembly and higher level languages. 
  Nobody was missing writing assembly code when C compiler was able to generate almost as good or even better machine code.
  
  
• When Python, C++ and Java and other "higher level" languages become available, C was still relevant for optimizations, but common tasks are delegated to interpreters, compilers, VMs etc.
  We just got more productive
  
  
• On UI side, we can hand-code every div and CSS and other, or we can re-use components, more optimal "lego blocks"
  
  
• AI code gen is one-level-up (from current code). Like C++ is to C. Not a big deal for humans, just one more step in levels of abstractions. We will just become much more productive.
  
  

 “The Era of Humans Writing Code is Over”: Why Ryan Dahl is Right | by Nisal Renuja Palliyaguru | Jan, 2026 | Medium

Ryan Dahl needs no introduction to the tech world. As the creator of Node.js and Deno, he is a true legend in the industry. Recently, however, a post he made on X (formerly Twitter) has sparked a massive debate within the global tech community.

“The era of humans writing code is over.”

As Software Engineers (SWEs) hearing this triggers an immediate, somewhat “disturbing” reaction. It strikes at the core of our identity. However, if we put emotions aside and look at this purely through a technical lens there is a profound truth in what Ryan is saying.

And this is view for a current prominent maintainer of node.js and other projects, Matteo Collina

I agree 100%  

The Future of the Software Engineering Career

Fundamentals Matter Again

"For the past decade, the industry focused on rapid delivery to employment. Learn React in twelve weeks. Build a portfolio. Get hired. Figure out the rest on the job.

That worked when companies needed bodies to type code. When the bottleneck was implementation speed, you could learn just enough to be useful and pick up the deeper knowledge later.

That world is gone.

When AI can implement features faster than any junior developer, what becomes valuable is the judgment to know whether the implementation is correct. And judgment requires understanding.

Algorithms. Distributed systems. Hardware architectures. Cache management techniques. Networking fundamentals. Database internals. These aren't academic exercises anymore. They're the foundation for evaluating AI-generated code."

Go AST (code <=> JSON)

To convert a Go program's Abstract Syntax Tree (AST) to JSON, you can use third-party command-line tools or Go packages. A popular choice is the asty tool, which offers a straightforward command-line interface and library for this purpose. 

Using the asty Command-Line Tool

The asty tool converts Go source files to an AST in JSON format (and vice versa). 

1. Install the asty tool:
   bash

   go install github.com
   

   This command installs the executable to your $GOPATH/bin directory.
2. Convert a Go file to JSON:
   Navigate to your source code directory and run the go2json command:
   bash

   asty go2json -input <input.go> -output <output.json>
   

   Replace <input.go> with the name of your Go source file and <output.json> with the desired output file name. 

Using Go Packages Programmatically

You can also use Go libraries within your own program to parse Go code and generate a JSON representation of its AST. 

Option 1: Using the asty Library

The asty library allows programmatic conversion of Go AST to JSON, providing a structure very close to real Go structs. 

• GitHub Repository: asty-org/asty
• Go Packages Documentation: pkg.go.dev/github.com/asty-org/asty 

Analyzing AST in Go with JSON tools - DEV Community

Option 2: Using g10z3r/ason

The ason library is another tool designed for serializing Go ASTs into JSON and deserializing them back, simplifying the process of analysis and modification. 

• GitHub Repository: g10z3r/ason 

These tools facilitate working with the Go AST outside of the standard library, which primarily uses the go/parser and go/ast packages without built-in direct JSON serialization. 

milahu/awesome-transpilers: A curated list of awesome transpilers. aka source-to-source compilers @GitHub

pseudo-lang/pseudo: transpile algorithms/libs to idiomatic JS, Go, C#, Ruby

tinygo-org/tinygo: Go compiler for small places. Microcontrollers, WebAssembly (WASM/WASI), and command-line tools. Based on LLVM. @GitHub

Why Go requires braces

Go's grammar is designed for fast, unambiguous parsing. The braces aren't just style — they're part of how the compiler avoids lookahead complexity. Semicolons are auto-inserted based on line endings, and braces delimit where statements begin/end unambiguously.

Theoretical alternatives

You could build a preprocessor or transpiler that converts indentation-based syntax to Go:

// Hypothetical "GoLite"
func main()
    if x > 0
        fmt.Println("positive")
    else
        fmt.Println("non-positive")

↓ transpiles to ↓

go

func main() {
    if x > 0 {
        fmt.Println("positive")
    } else {
        fmt.Println("non-positive")
    }
}

Existing experiments

• Oden (discontinued) — was a Lisp-like language targeting Go
• Have — https://github.com/piotr-skotnicki/have — experimental indentation-based Go alternative
• Og — https://github.com/piot/og — "Offside Go", uses indentation instead of braces

Have (Python-like syntax transpiling to Go)

• GitHub: https://github.com/vrok/have
• Website: http://havelang.org (may be defunct now)

I apologize for the earlier broken link. The project I incorrectly named "Have" with a different author doesn't exist — there's only this one by vrok.

As for "Og" (Offside Go), my searches didn't find a current repository for it — it may have been an experimental project that's since been removed or renamed.

Other alternatives that do exist:

• Oden — functional language that compiled to Go (discontinued): https://github.com/oden-lang/oden
• GopherJS — Go to JavaScript: https://github.com/gopherjs/gopherjs
• c2go — C to Go transpiler: https://github.com/elliotchance/c2go

If you're interested in the braceless/indentation concept, Have is the most direct example, though it appears to be unmaintained (last commits were several years ago).