I like lisp because code is data
Yes I have, it's definitely a viable option and a full backend to target qbe could be made in about 6-12 hours or less probably. My plan is to write my own backend from scratch for x86_64 Linux and output the object/exe directly like tcc, so no dependencies
IMO haskells API docs ( https://hoogle.haskell.org/ ) is top tier. You can just search for any function signature and find whatever you need, most likely.
I don't even disagree with you here. Just trying to find a bridge that might work is all. I agree with your position here. That said, LLMs have gotten really good at code lately. Gemini now beats the pet inadequacy I'd been using to test LLMs with. Gotta find a new one...
Boom, fully
dash compatible.(
s="89a1b14a083c792c80b4e0ad9e223dbf_6974d89d"
d=16
n=45300
target="$((1 << (32 - $d)))"
until h=`printf "%s%d" "$s" "$n" | sha256sum | cut -c1-8` && [ $((0x$h)) -lt "$target" ]; do
n=$(($n+1))
done
printf "%d\n" "$n"
)I use Claude Code a lot for grunt work, go here refactor this, read all the code design 4 API options to refactor into, search the internet for x and compile a report (more reliable than using only its training data), build a prototype x from this document and then use it to define the APIs and data models up front so I can decide the best course, etc you can gain a lot of productivity doing this. It's viable to let it do the coding for real but you can't let it decide things, you always have to read every line of the change log and make corrections.
The number of times they get it wrong far outnumbers how often they get it right, so just RTFM yourself. Using it to find relevant sections of documentation is fair, especially considering how horrible people are at naming things, but past that point you should be reading it yourself. If it's good documentation you can understand it without an AI reading it to you; if it's bad documentation then the AI won't be able to "understand" it well enough to turn it into good documentation
The last few times I've messed around with AI it insisted every single time that you could return array types from functions in C, even coming up with its own niggerlicious syntax for it. I don't even know where it pulled such an idea in the first place (maybe some man page that uses puedo-C syntax) but that alone is enough to convince me it has no business doing anything outside of glorified searches for me
What model? It's gotten much better since those days, it will compile and see that their are errors and go fix them, or it'll run the tests to verify everything is still working
I use it for C C++, it's definitely a different way of working but it can be much more efficient or if it's something you don't want to do, like a refactor that touches 10,000 lines
I think it's the opposite, if the documentation is shit then why would I want to read it instead of the LLM, at least it can make sense of it potentially
"Samir, you checked all 10k lines to make sure the LLM didn't introduce any unintended behaviour, remove essential behaviour, and the code it produced adheres to our project's guidelines and conventions?"
The jeet doth protest too much. What kind of a white man can't command slaves?
I usually like going for man pages. If it's not C you probably won't have man pages to use though, unfortunately. also glibc has it's documentation in texinfo, which is even more in depth. But again, obviously it's only going to be for linux, and C.
package main
import (
"encoding/json"
"fmt"
"io"
"net/http"
"os"
"time"
"github.com/joho/godotenv"
)
type Guild struct {
ID string `json:"id"`
Name string `json:"name"`
Icon string `json:"icon"`
Owner bool `json:"owner"`
Permissions string `json:"permissions"`
Features []string `json:"features"`
}
var cfg struct {
Port int `env:"PORT"`
}
func main() {
err := godotenv.Load()
if err != nil {
panic(err)
}
AuthToken := os.Getenv("authorization")
println(AuthToken)
client := &http.Client{
Timeout: 10 * time.Second,
}
req, err := http.NewRequest(
"GET",
"https://discord.com/api/v10/users/@me/guilds",
nil,
)
if err != nil {
panic(err)
}
req.Header.Set("Authorization", AuthToken)
req.Header.Set("Content-Type", "application/json")
resp, err := client.Do(req)
if err != nil {
panic(err)
}
defer resp.Body.Close()
if resp.StatusCode != http.StatusOK {
body, _ := io.ReadAll(resp.Body)
panic(fmt.Sprintf("Discord API error: %d - %s", resp.StatusCode, body))
}
body, err := io.ReadAll(resp.Body)
if err != nil {
panic(err)
}
var guilds []Guild
if err := json.Unmarshal(body, &guilds); err != nil {
panic(err)
}
for _, g := range guilds {
fmt.Printf("Guild: %s (%s)\n", g.Name, g.ID)
}
}How doable this is depends a bit on how well-written the docs are, but try to get a handle on the fundamental concepts first. Good software tends to be built around a few central definitions/datatypes, and without understanding those it's going to be really awkward to use; you're not going to get far with Numpy if you don't understand what an ndarray is. Especially good documentation will have a glossary or an intro section that explains these concepts. It's similar to how in mathematics, you're not going to understand the proofs of theorems if you don't understand the definitions.
I honestly just read the code in most cases and use the documentation as a backup. Unless the project in question has really amazing documentation with multiple examples per function.
Consider using a json.Decoder to decode more efficiently directly from the resp.Body Reader rather than reading it all into a slice with io.ReadAll.
Anything that Indians can't afford, Claude Code opus is decent
Opus, Deepseek-Code, GLM 4.7, Gemini 3 Pro, Grok Code, Qwen3-Coder, Minimax-M2.1.. I personally recommend Opus, Gemini 3 Pro and GLM as they're the best ones in the market rn (these are my personal preferences, its really up to you depending on your goals and what you wanna do).
The only good thing about ChatGPT is it's off cooldown when your Claude usage is maxed, if you're not managing cool downs and sustain like an MMO you're ngmi. If I don't maintain 100% uptime on my agentic tasks my family in India will starve to death
I start with their examples and get something working. I try to extract the author's intent from how they use classes and types and functions or whatever language features are on hand, to extend the example to my use case.