home.social

#softwareengineering — Public Fediverse posts

Live and recent posts from across the Fediverse tagged #softwareengineering, aggregated by home.social.

  1. The model does not know what you have already tried. You ruled something out twenty minutes ago, the reasoning stayed in your head, and now every suggestion walks back through the door you closed. It is not repeating. You never said it was off the table.

    #AI #Prompting #SoftwareEngineering #BuildInPublic #DevTools

  2. The model does not know what you have already tried. You ruled something out twenty minutes ago, the reasoning stayed in your head, and now every suggestion walks back through the door you closed. It is not repeating. You never said it was off the table.

    #AI #Prompting #SoftwareEngineering #BuildInPublic #DevTools

  3. The model does not know what you have already tried. You ruled something out twenty minutes ago, the reasoning stayed in your head, and now every suggestion walks back through the door you closed. It is not repeating. You never said it was off the table.

    #AI #Prompting #SoftwareEngineering #BuildInPublic #DevTools

  4. The model does not know what you have already tried. You ruled something out twenty minutes ago, the reasoning stayed in your head, and now every suggestion walks back through the door you closed. It is not repeating. You never said it was off the table.

    #AI #Prompting #SoftwareEngineering #BuildInPublic #DevTools

  5. The model does not know what you have already tried. You ruled something out twenty minutes ago, the reasoning stayed in your head, and now every suggestion walks back through the door you closed. It is not repeating. You never said it was off the table.

    #AI #Prompting #SoftwareEngineering #BuildInPublic #DevTools

  6. Lógica de Sistemas e Introspección

    En ingeniería de sistemas aprendes rápido que el problema real casi nunca es la sintaxis del lenguaje, sino el modelo mental detrás del problema. Optimizar una consulta SQL o entender el cuello de botella en la memoria enseña más sobre estructuras y algoritmos que cualquier framework de moda. Fundamentos > Hype. 🧠

    #SoftwareEngineering #ComputerScience #Database #Backend #Programming

  7. AI didn’t replace good engineering habits - it made them mandatory!

    Tests? The only proof AI-generated code actually works.
    Docs? Context agents need to avoid blowing up production.

    The exact habits engineers used to skip are now critical to survival in the age of AI!

    🗓️ Full presentation goes live on InfoQ on September 30, 2026. Mark your calendar!

    #DevOps #SoftwareEngineering #AI #InfoQ #GenerativeAI

  8. Imagine a #future where people will have forgotten the knowledge to program a computer.

    We're heading towards this future.

    #SoftwareDevelopment #SoftwareEngineering #Prediction #LLM #LLMs

  9. Imagine a #future where people will have forgotten the knowledge to program a computer.

    We're heading towards this future.

    #SoftwareDevelopment #SoftwareEngineering #Prediction #LLM #LLMs

  10. Imagine a #future where people will have forgotten the knowledge to program a computer.

    We're heading towards this future.

    #SoftwareDevelopment #SoftwareEngineering #Prediction #LLM #LLMs

  11. Imagine a #future where people will have forgotten the knowledge to program a computer.

    We're heading towards this future.

    #SoftwareDevelopment #SoftwareEngineering #Prediction #LLM #LLMs

  12. Imagine a #future where people will have forgotten the knowledge to program a computer.

    We're heading towards this future.

    #SoftwareDevelopment #SoftwareEngineering #Prediction #LLM #LLMs

  13. The LLM in the room — Going beyond using AI to do someone else’s job badly

    People mostly use artificial intelligence to do the jobs they didn’t value anyway. But this amounts to cutting our colleagues out. Value must be created through human-to-human exchanges. So we should rapidly focus on uses of AI that go beyond trying to do someone else’s job badly.

    duncanstephen.net/the-llm-in-t

  14. The LLM in the room — Going beyond using AI to do someone else’s job badly

    People mostly use artificial intelligence to do the jobs they didn’t value anyway. But this amounts to cutting our colleagues out. Value must be created through human-to-human exchanges. So we should rapidly focus on uses of AI that go beyond trying to do someone else’s job badly.

    duncanstephen.net/the-llm-in-t

  15. The LLM in the room — Going beyond using AI to do someone else’s job badly

    People mostly use artificial intelligence to do the jobs they didn’t value anyway. But this amounts to cutting our colleagues out. Value must be created through human-to-human exchanges. So we should rapidly focus on uses of AI that go beyond trying to do someone else’s job badly.

    duncanstephen.net/the-llm-in-t

  16. The LLM in the room — Going beyond using AI to do someone else’s job badly

    People mostly use artificial intelligence to do the jobs they didn’t value anyway. But this amounts to cutting our colleagues out. Value must be created through human-to-human exchanges. So we should rapidly focus on uses of AI that go beyond trying to do someone else’s job badly.

    duncanstephen.net/the-llm-in-t

  17. The LLM in the room — Going beyond using AI to do someone else’s job badly

    People mostly use artificial intelligence to do the jobs they didn’t value anyway. But this amounts to cutting our colleagues out. Value must be created through human-to-human exchanges. So we should rapidly focus on uses of AI that go beyond trying to do someone else’s job badly.

    duncanstephen.net/the-llm-in-t

  18. What if #SystemsThinking could change how you deliver software?

    Elisabeth Hendrickson & Joel Tosi explore systems thinking, the cultural levers leaders can pull, and how to build sustainable teams through AI-driven change.

    🎧 Listen to the #InfoQ podcast: infoq.com/podcasts/building-th

    #SoftwareEngineering #SoftwareDelivery #Leadership #TeamCulture #AI

  19. What if #SystemsThinking could change how you deliver software?

    Elisabeth Hendrickson & Joel Tosi explore systems thinking, the cultural levers leaders can pull, and how to build sustainable teams through AI-driven change.

    🎧 Listen to the #InfoQ podcast: infoq.com/podcasts/building-th

    #SoftwareEngineering #SoftwareDelivery #Leadership #TeamCulture #AI

  20. What if #SystemsThinking could change how you deliver software?

    Elisabeth Hendrickson & Joel Tosi explore systems thinking, the cultural levers leaders can pull, and how to build sustainable teams through AI-driven change.

    🎧 Listen to the #InfoQ podcast: infoq.com/podcasts/building-th

    #SoftwareEngineering #SoftwareDelivery #Leadership #TeamCulture #AI

  21. What if #SystemsThinking could change how you deliver software?

    Elisabeth Hendrickson & Joel Tosi explore systems thinking, the cultural levers leaders can pull, and how to build sustainable teams through AI-driven change.

    🎧 Listen to the #InfoQ podcast: infoq.com/podcasts/building-th

    #SoftwareEngineering #SoftwareDelivery #Leadership #TeamCulture #AI

  22. What if could change how you deliver software?

    Elisabeth Hendrickson & Joel Tosi explore systems thinking, the cultural levers leaders can pull, and how to build sustainable teams through AI-driven change.

    🎧 Listen to the podcast: infoq.com/podcasts/building-th

  23. Well, look at that: nothing saves you from a logic bug! Not even if the code is in Rust and an AI writes it!

    GitHub recently published an interesting post with data from porting the Copilot runtime from TypeScript to Rust: we're talking about over 800,000 lines of production Rust, largely generated by agents, in about 14 weeks, with a single developer coordinating the work.
    Reading it, there are two numbers worth looking at closely, because they put a couple of common claims into perspective.

    - "Rust is the best target for AI-written code because the compiler is strict." During the project, GitHub logged 8678 compiler errors. 84% were fairly mundane stuff: wrong names, missing pieces of code, incompatible types... all things considered, these are errors that plenty of other modern languages with strong compilers would catch just as well. On the other hand, errors specific to Rust's ownership and borrowing system were only 1.7% of the total. So the argument that "AI writes better code because Rust has a very strict compiler" doesn't hold up that well, given that most of the advantage you're describing actually comes from having a strongly typed language and a compiler that provides a lot of feedback. I don't think that's exclusive to Rust.
    - "If it compiles, it's correct." Here the post gets even juicier; GitHub says explicitly that every regression on their list had been merged into `main`, meaning the code compiled just fine. Put simply, the compiler can't know that an ID needs to be stored as `42` and not `42.0`, or that two counters always need to advance together. Basically, it can't know that a state machine is producing the wrong result. And it can't notice that a rebase silently dropped a safety check along with its test. Still on that note, during an automated merge, an agent had deleted a function used by the SDK. The automated check caught it and blocked the merge. The agent's response was to apply "schema-break-ok", the label that lets you bypass that check. Problem: the change wasn't intentional. The function had simply gone missing during the port. (!) An obsolete human being, aka the developer, caught it during review, had the waiver removed, and had the function restored.

    AI can write 800,000 lines. The compiler can check them but neither one, on its own, can tell you whether you built the right thing.
    That's why you need tests, automated checks, review, and, with all due respect to the doomsayers with other people's resumes, someone who can actually understand why a check is failing instead of just making it pass.

    #AICoding #GitHubCopilot #SoftwareEngineering #AISecurity

  24. Well, look at that: nothing saves you from a logic bug! Not even if the code is in Rust and an AI writes it!

    GitHub recently published an interesting post with data from porting the Copilot runtime from TypeScript to Rust: we're talking about over 800,000 lines of production Rust, largely generated by agents, in about 14 weeks, with a single developer coordinating the work.
    Reading it, there are two numbers worth looking at closely, because they put a couple of common claims into perspective.

    - "Rust is the best target for AI-written code because the compiler is strict." During the project, GitHub logged 8678 compiler errors. 84% were fairly mundane stuff: wrong names, missing pieces of code, incompatible types... all things considered, these are errors that plenty of other modern languages with strong compilers would catch just as well. On the other hand, errors specific to Rust's ownership and borrowing system were only 1.7% of the total. So the argument that "AI writes better code because Rust has a very strict compiler" doesn't hold up that well, given that most of the advantage you're describing actually comes from having a strongly typed language and a compiler that provides a lot of feedback. I don't think that's exclusive to Rust.
    - "If it compiles, it's correct." Here the post gets even juicier; GitHub says explicitly that every regression on their list had been merged into `main`, meaning the code compiled just fine. Put simply, the compiler can't know that an ID needs to be stored as `42` and not `42.0`, or that two counters always need to advance together. Basically, it can't know that a state machine is producing the wrong result. And it can't notice that a rebase silently dropped a safety check along with its test. Still on that note, during an automated merge, an agent had deleted a function used by the SDK. The automated check caught it and blocked the merge. The agent's response was to apply "schema-break-ok", the label that lets you bypass that check. Problem: the change wasn't intentional. The function had simply gone missing during the port. (!) An obsolete human being, aka the developer, caught it during review, had the waiver removed, and had the function restored.

    AI can write 800,000 lines. The compiler can check them but neither one, on its own, can tell you whether you built the right thing.
    That's why you need tests, automated checks, review, and, with all due respect to the doomsayers with other people's resumes, someone who can actually understand why a check is failing instead of just making it pass.

    #AICoding #GitHubCopilot #SoftwareEngineering #AISecurity

  25. Well, look at that: nothing saves you from a logic bug! Not even if the code is in Rust and an AI writes it!

    GitHub recently published an interesting post with data from porting the Copilot runtime from TypeScript to Rust: we're talking about over 800,000 lines of production Rust, largely generated by agents, in about 14 weeks, with a single developer coordinating the work.
    Reading it, there are two numbers worth looking at closely, because they put a couple of common claims into perspective.

    - "Rust is the best target for AI-written code because the compiler is strict." During the project, GitHub logged 8678 compiler errors. 84% were fairly mundane stuff: wrong names, missing pieces of code, incompatible types... all things considered, these are errors that plenty of other modern languages with strong compilers would catch just as well. On the other hand, errors specific to Rust's ownership and borrowing system were only 1.7% of the total. So the argument that "AI writes better code because Rust has a very strict compiler" doesn't hold up that well, given that most of the advantage you're describing actually comes from having a strongly typed language and a compiler that provides a lot of feedback. I don't think that's exclusive to Rust.
    - "If it compiles, it's correct." Here the post gets even juicier; GitHub says explicitly that every regression on their list had been merged into `main`, meaning the code compiled just fine. Put simply, the compiler can't know that an ID needs to be stored as `42` and not `42.0`, or that two counters always need to advance together. Basically, it can't know that a state machine is producing the wrong result. And it can't notice that a rebase silently dropped a safety check along with its test. Still on that note, during an automated merge, an agent had deleted a function used by the SDK. The automated check caught it and blocked the merge. The agent's response was to apply "schema-break-ok", the label that lets you bypass that check. Problem: the change wasn't intentional. The function had simply gone missing during the port. (!) An obsolete human being, aka the developer, caught it during review, had the waiver removed, and had the function restored.

    AI can write 800,000 lines. The compiler can check them but neither one, on its own, can tell you whether you built the right thing.
    That's why you need tests, automated checks, review, and, with all due respect to the doomsayers with other people's resumes, someone who can actually understand why a check is failing instead of just making it pass.

    #AICoding #GitHubCopilot #SoftwareEngineering #AISecurity