Location: Accra, Ghana

Remote: Yes (or hybrid)

Willing to relocate: Yes

Technologies:

    - Core: Rust, C/C++, Solidity, PostgreSQL, WebAssembly

    - Domain: Zero Knowledge Proofs (ZKPs), Solana, compilers

    - Tools/Libraries: Winterfell, Arkworks, RISC0 zkVM, Solana Anchor

Résumé/CV: https://drive.google.com/file/d/1TxkqTKGxYuio0WN_3lk3Bdfj3ZN...

Email: kobby5angels@gmail.com

LinkedIn: https://www.linkedin.com/in/kobbypentangeli/

GitHub: https://github.com/kobby-pentangeli

Rust/C++ cryptography engineer with strong bias towards zero-knowledge proofs (ZKPs) and compilers. Currently leading the open-source implementation of a Turing-complete programming language for writing ZKPs; Rust-native syntax, Winterfell STARK backend: https://github.com/maatlabs/maat

The elephant in the room, of course, is what constitutes “meaningful human authorship.” However, I cannot shake off the feeling that all user interactions with these AI models are being logged. Perhaps this may turn out to be the bigger concern in a potential legal battle than code authorship.

The meaningful human authorship question is the elephant, agreed, and the regulators have deliberately refused to quantify it for exactly the reason you describe any bright line number becomes a target to game rather than a standard to meet.

The logging point is sharper than it might appear. In a copyright dispute over AI-assisted code, interaction logs could cut both ways. A plaintiff trying to establish human authorship would want the logs to show substantial architectural redirection, multiple rejections of Claude output, and documented reasoning for structural decisions. A defendant challenging that authorship claim would subpoena the same logs to show verbatim acceptance of output without modification.

The practical implication i guess here,that the developers who want to preserve a copyright claim over AI-assisted code should treat their prompt history as a legal document from the start. It seems all over the world the logs are the evidence. Whether they help or hurt depends entirely on what they show.

The bit about treating one’s prompt history as a legal document has really struck a nerve with me. I’ve been keeping a separate git history solely for my prompts. Initially, the goals were simple: reuse prompts, turn some into skills, etc. But in light of the insights from the article and the discussions here, I need to treat this practice as serious business.

I’ve used Rust daily for the last 6 years; from writing compilers and WASM runtimes to writing smart contracts and SDKs… and the experience has been nothing short of amazing.

I’m not sure what you mean by a “casual setup,” but I find Cargo to be very easy to use. Granted, compilation can be pretty slow, but it’s a small price to pay for the runtime performance.

If by “faster feedback” you mean something that looks and feels like Python’s REPL, then I think you’re missing the point here. Rust is a compiled language.

I’m a little conflicted on this, as I see a slippery slope here. LLMs in their current state (e.g., Opus-4.7) are really good in planning and one-shot codegen, which I believe is their primary use case. So they do provide enough leverage in that regard.

With this new workflow, however, we should, uncompromisingly, steer the entire code review process. The danger here, the “slippery slope,” is that we’re constantly craving for more intelligent models so we can somehow outsource the review to them as well. We may be subconsciously engineering ourselves into obsolescence.

Subconsciously?!?

Lol! Wrong choice of word, maybe. I meant to say that we don’t seem to be putting much thought into how we’re outsourcing thinking to the LLMs.

Some of us very much are, and we are ignored and/or attacked by people who don’t think about this quite often.

This is such an interesting time to be in. Truly skilled developers like Rob Pike really don’t like AI, but many professional developers love it. I side with Mr. Pike on it all.

I am not a skilled developer like he is, but I do like to think about what I’m doing and to plan for the future when writing code that might be part of that future. I like very simple code which is easy to read and to understand, and I try quite hard to use data types which can help me in multiple ways at once. The feeling when you solve a problem you’ve never solved before is indescribable, and bots strip all of that away from you and they write differently than I would.

I don’t think any bot would ever come up with something like Plan9 without explicit instructions, and that single example showcases what bots can’t do: think about what is appropriate when doing something new.

I don’t know what is right and what is wrong here, I just know that is an interesting time.

The rate of improvement has given us no time to think at all. The past 3 years of progress should have been spread over the next 30 years to even give us a chance.

That seems to be the general direction, at least from my daily dose of cope on X (Twitter). Regardless, conscious design will never go out of style.