AI profitability

[Bootstrap]

I code and analyze data for hours, most days, using both tools. I have environments where I can just change one line in a file to change the tool that is used, or switch windows and try the other, so I compare fairly often.

Claude has always worked better for me for coding. Open AI is often better for analyzing text in some ways, but that depends on what the task is. I know a lot of programmers who use AI tools for coding. For a lot of software people, actually visualizing and designing the system is more interesting and rewarding than writing tests, devops, code review, etc., and we are better at some aspects than others, so this has been a very successful area for AI. I have been to conferences where I discuss these things with other developers, and I regularly talk with them online. I think the trend is to use Claude more for coding, Open AI for other tasks.

I don't know much about where they get their profits from. Venture capital is often shrouded. These companies get a lot of money from government, DOD, defense, political parties, and other sources that do not want transparency. And there is overlap - the venture capitalists are deeply invested in politicians who grant favors to AI companies. To the point that any regulation of AI at all has been seen as politically dangerous. And the government has granted them access to all kinds of information. We don't even know what that includes. So when we ask about profitability, there is a lot beneath the surface. And of course, venture capitalists do not always need quick profitability. AI companies are often becoming the "power behind the power" in some settings, which gives them leverage in ways useful to them.

I do not know how much this leads to general prosperity in the long run. I do know that not much of the wealth that is getting created is going to be taxed, and it is raising the need for energy and the cost of energy and many other things for all of us. We are all subsidizing these companies. They will make lots of wealth that will be passed on from generation to generation without being taxed.

[Anthony]

If anyones used these tools its obvious it resulted in massive productivity gains, the “AI is a bubble” talk is obvious cope. Accordingly i have most of my money invested in tech stocks/ETFs #vestedinterest

[JohnH]

If anyones used these tools its obvious it resulted in massive productivity gains, the “AI is a bubble” talk is obvious cope. Accordingly i have most of my money invested in tech stocks/ETFs #vestedinterest

An increase of 10-15% seems realistic.

I have yet to see some meteoric rise in the quality of open source software, nor anything really significant in terms of quantity. There is lots of vibe coded slop showing up, though.

Big corporations haven’t logged any productivity gains at all. Prices for the consumer haven’t gone down either.

[Soloist]

If you’re careful, you can code usable products, even if you don’t know how to code. Testing validation are heavy pieces of it. If you build a product you can’t test it’s going to be garbage.
If you build a product and test it and don’t revise repeatedly, it’s going to be garbage.

Someone could do everything I did in a few days of coding and it took me several months, but without it, I would not have produced any product.

[Bootstrap]

If you’re careful, you can code usable products, even if you don’t know how to code. Testing validation are heavy pieces of it. If you build a product you can’t test it’s going to be garbage.
If you build a product and test it and don’t revise repeatedly, it’s going to be garbage.

Someone could do everything I did in a few days of coding and it took me several months, but without it, I would not have produced any product.

This is a really big deal. People who know something about a particular domain and see a market need can create simple apps without a team of programmers. And if you ever want to work with programmers, you can show them prototypes so they get what you need. AI profitability for the little guy who knows something.

I think we will see a lot of this.

Test, test, test is a great strategy. Before I write any code, I write the following, often with help from the AI, going back and forth until it looks good to me:

1. A problem statement. What problem are we trying to solve in the next step? How will I know when it is solved?
2. Specification - how does the AI plan to solve the problem? Someone with software background can see problems in what the AI proposes that you can't, but this still useful so you can see what the AI plans to do. If you don't understand it, ask the AI to explain it to you. I put this in a github isse.
3. Tests that fail because the solution is not there. They will pass when it has been implemented. Run the tests, show that they fail. If they don't, the AI may be telling you about a problem it has misdiagnosed.
4. Implementation - now write the code and run the tests until they pass. Keep the tests in your test suite, because the AI may eventually break what you just worked hard to do.

Make sure you use source code control, like GitHub. If you do not know what Github is or how to use it, your AI can explain it to you. Never let the AI skip a step.

Make sure you do security audits, especially if your program collects money in any way.

[JohnH]

If you’re careful, you can code usable products, even if you don’t know how to code. Testing validation are heavy pieces of it. If you build a product you can’t test it’s going to be garbage.
If you build a product and test it and don’t revise repeatedly, it’s going to be garbage.

Someone could do everything I did in a few days of coding and it took me several months, but without it, I would not have produced any product.

This is a really big deal. People who know something about a particular domain and see a market need can create simple apps without a team of programmers. And if you ever want to work with programmers, you can show them prototypes so they get what you need. AI profitability for the little guy who knows something.

How is this any different from COBOL in the 1960s, (intended for business people to be able to write programs), SQL (intended for office staff to write queries) in the 1970s, BASIC in the
1980s, CASE in the 1990s, and then in the more recent era, “no-code apps”?

All of these allowed non-programmers to write simple applications.

[Bootstrap]

If you’re careful, you can code usable products, even if you don’t know how to code. Testing validation are heavy pieces of it. If you build a product you can’t test it’s going to be garbage.
If you build a product and test it and don’t revise repeatedly, it’s going to be garbage.

Someone could do everything I did in a few days of coding and it took me several months, but without it, I would not have produced any product.

This is a really big deal. People who know something about a particular domain and see a market need can create simple apps without a team of programmers. And if you ever want to work with programmers, you can show them prototypes so they get what you need. AI profitability for the little guy who knows something.

How is this any different from COBOL in the 1960s, (intended for business people to be able to write programs), SQL (intended for office staff to write queries) in the 1970s, BASIC in the
1980s, CASE in the 1990s, and then in the more recent era, “no-code apps”?

All of these allowed non-programmers to write simple applications.

Most of these did not actually allow non-programmers to write simple applications. They made it easier for non-programmers to become programmers by learning the kinds of thinking programmers use. And each generation of tools was simpler and higher-level than the tools that came before it.

For instance, here's a simple sort in COBOL, which is a programming language, after all. I have programmed in COBOL and taught people COBOL, I'm that old. But I don't think it is easy to read compared to most programming languages. If you can write this, I would call you a programmer. And a senior citizen.

Code: Select all

       
PERFORM VARYING I FROM 1 BY 1 UNTIL I >= N
    PERFORM VARYING J FROM 1 BY 1 UNTIL J > N - I
               IF NUMBERS(J) > NUMBERS(J + 1)
                   MOVE NUMBERS(J) TO TEMP
                   MOVE NUMBERS(J + 1) TO NUMBERS(J)
                   MOVE TEMP TO NUMBERS(J + 1)
               END-IF
    END-PERFORM
END-PERFORM.

Before I learned COBOL, I learned IBM SYS 360 Assembly Language. Here's the same sort in IBM 360:

Code: Select all

         LA    R1,ARRAY
         L     R2,N
OUTER    BCTR  R2,0
         LTR   R2,R2
         BZ    DONE
         LA    R3,0
         LA    R4,0
INNER    L     R5,0(R1,R4)
         L     R6,4(R1,R4)
         CR    R5,R6
         BNH   NOSWAP
         ST    R6,0(R1,R4)
         ST    R5,4(R1,R4)
NOSWAP   LA    R4,4(R4)
         BCT   R2,INNER
         B     OUTER
DONE     BR    R14

N        DC    F'5'
ARRAY    DC    F'5',F'1',F'4',F'2',F'8'

So yes, COBOL is easier ... and we have been trying to make it easier ever since. Spreadsheets were a major step forward for a well defined class of problems. So is Monday.com. Now they are adding AI functionality.

If I do this with a .gpt file in my pipline, I do it like this:

Code: Select all

Sort {{numbers}}

or

Code: Select all

Which numbers in {{numbers}} are odd primes?  Show them in reverse numerical order.[/code}

I don't have to know the functions available in a programming library to do that.  I can also  say this:

[code]Write me a python function to  solve this problem:

Which numbers in {{numbers}} are odd primes?  Show them in reverse numerical order.

And it gives me this:

Code: Select all

def odd_primes_desc(numbers):
    def is_prime(n):
        if n < 2:
            return False
        if n == 2:
            return True
        if n % 2 == 0:
            return False

        for i in range(3, int(n ** 0.5) + 1, 2):
            if n % i == 0:
                return False

        return True

    return sorted(
        [n for n in numbers if n % 2 == 1 and is_prime(n)],
        reverse=True
    )

I can say this:

Code: Select all

Write me a test suite for that function. Make sure there is adequate coverage. Show me the results.

It tells me this:

Code: Select all

def odd_primes_desc(numbers):
    def is_prime(n):
        if n < 2:
            return False
        if n == 2:
            return True
        if n % 2 == 0:
            return False

        for i in range(3, int(n ** 0.5) + 1, 2):
            if n % i == 0:
                return False

        return True

    return sorted(
        [n for n in numbers if n % 2 == 1 and is_prime(n)],
        reverse=True
    )


def run_tests():
    tests = [
        {
            "name": "mixed primes and composites",
            "input": [2, 3, 4, 5, 7, 9, 11, 15, 17],
            "expected": [17, 11, 7, 5, 3],
        },
        {
            "name": "empty list",
            "input": [],
            "expected": [],
        },
        {
            "name": "no primes",
            "input": [0, 1, 4, 6, 8, 9, 10, 12, 15],
            "expected": [],
        },
        {
            "name": "only even prime",
            "input": [2],
            "expected": [],
        },
        {
            "name": "negative numbers ignored",
            "input": [-11, -7, -3, 3, 5],
            "expected": [5, 3],
        },
        {
            "name": "already descending",
            "input": [19, 17, 13, 11, 7, 5, 3],
            "expected": [19, 17, 13, 11, 7, 5, 3],
        },
        {
            "name": "ascending input sorted descending",
            "input": [3, 5, 7, 11, 13, 17, 19],
            "expected": [19, 17, 13, 11, 7, 5, 3],
        },
        {
            "name": "duplicates preserved",
            "input": [3, 3, 5, 5, 9, 11, 11],
            "expected": [11, 11, 5, 5, 3, 3],
        },
        {
            "name": "square of prime excluded",
            "input": [25, 49, 121, 13],
            "expected": [13],
        },
        {
            "name": "larger odd primes",
            "input": [97, 89, 91, 93, 101],
            "expected": [101, 97, 89],
        },
    ]

    passed = 0

    for test in tests:
        actual = odd_primes_desc(test["input"])
        assert actual == test["expected"], (
            f'{test["name"]}: expected {test["expected"]}, got {actual}'
        )
        passed += 1
        print(f'PASS: {test["name"]}')

    print(f"\n{passed}/{len(tests)} tests passed.")


run_tests()

And this:

Code: Select all

PASS: mixed primes and composites
PASS: empty list
PASS: no primes
PASS: only even prime
PASS: negative numbers ignored
PASS: already descending
PASS: ascending input sorted descending
PASS: duplicates preserved
PASS: square of prime excluded
PASS: larger odd primes

10/10 tests passed.

[Bootstrap]

I think those examples show that I did not need to program or understand programming languages to have Claude write code and test it. I can also ask Claude to add these tests to my test suite.

I have taught people to program. It is much easier to teach them to do this. Domain knowledge and software engineering discipline become more valuable than actual coding. Learning to write good specs. Making sure you and the LLM both know what problem you think you are trying to solve.

[JohnH]

I think those examples show that I did not need to program or understand programming languages to have Claude write code and test it. I can also ask Claude to add these tests to my test suite.

I have taught people to program. It is much easier to teach them to do this. Domain knowledge and software engineering discipline become more valuable than actual coding. Learning to write good specs. Making sure you and the LLM both know what problem you think you are trying to solve.

Is there a reason you ignored my examples post-1960, particularly CASE and “no code”?

In any case a sort in COBOL is done like this:

Code: Select all

SORT my-sort
       USING input-file
       GIVING output-file.

The premise of COBOL is that is a normal English sentence and easy for non-programmers to write and understand.

[Bootstrap]

In any case a sort in COBOL is done like this:

Code: Select all

SORT my-sort
       USING input-file
       GIVING output-file.

The premise of COBOL is that is a normal English sentence and easy for non-programmers to write and understand.

Yes, that's the premise. Which is why we have masses of COBOL code few people know how to maintain. What's hard about programming is not writing one line or one function.

Do you regularly program in COBOL? I haven't used it since perhaps 1982.