DEV Community: Naftali M

Intellectual Capacity and the Impacts of Generative AI

Naftali M — Thu, 12 Jun 2025 17:33:50 +0000

Intellectual capacity refers to the ability of individuals to think, reason, analyze, and generate ideas. It encompasses both creative and critical thinking abilities, forming the foundation of innovation, education, and scientific advancement. With the rapid development and integration of generative artificial intelligence (GenAI) into various domains, questions have emerged regarding the effects on human intellectual capacity, the opportunities and challenges to creativity and critical thinking, and the implications for intellectual property (IP). This article explores these dimensions, highlighting the benefits and limitations of GenAI while considering future directions and regulatory concerns related to intellectual property.

Generative AI systems capable of producing text, images, music, code, and more based on learned patterns from data has transformed the way people interact with information and express creativity. Tools such as OpenAI’s ChatGPT, Google’s Gemini, and image generators like Midjourney can enhance human productivity and serve as intellectual partners in brainstorming, content creation, and problem-solving. They can augment intellectual capacity in a variety of ways.

GenAI helps users overcome writer’s block, generate artistic concepts, and prototype ideas rapidly. According to McCormack et al. (2020), creative AI systems can act as co-creators, expanding human imagination across various aspects. While GenAI may be seen as a shortcut, it can stimulate critical reflection when used properly. Users are often prompted to verify, refine, or question AI-generated content, which can encourage deeper engagement with information.

However, there are significant concerns regarding the overreliance on AI, which may lead to the diminishment of original thought and intellectual autonomy. Carr (2010) warned about the "Google effect" where dependence on external tools reduces memory retention and analytical rigor. With GenAI, this concern is magnified, especially in educational settings where students might bypass learning processes by using AI-generated essays and answers.

Despite the benefits, the creative and critical use of GenAI raises several pressing issues:
Works created with the aid of GenAI blur the lines between human and machine authorship. Who owns the rights to a painting generated by AI trained on hundreds of human artists? Courts and IP offices are grappling with these questions. In Thaler v. Perlmutter (2023), the U.S. Copyright Office ruled that purely AI-generated works cannot be copyrighted, reinforcing the principle that copyright requires human authorship.
GenAI tools are only as unbiased as their training data. They may reproduce and amplify societal biases or misinformation embedded in their data sets (Bender et al., 2021). When used uncritically, this can reinforce stereotypes and lead to flawed decision-making.
In academic settings, Generative AI introduces complex challenges in identifying plagiarism. Although AI-generated content is not typically copied verbatim, it often rephrases established ideas or unintentionally reflects existing works, thereby complicating assessments of originality. The issue becomes more pronounced when students who frequently rely on GenAI attempt to write independently; they are likely to adopt the AI's distinctive voice and tone, potentially blurring the line between original thought and machine influence.

GenAI models, such as GPT, do not comprehend content like humans do. Instead, they operate by statistically predicting the most likely sequence of words based on the input they receive and the patterns they’ve learned from massive datasets. These models are trained on large text corpora and identify patterns, but they do not possess consciousness, intent, or actual understanding of meaning. When responding, they simply generate what appears likely to follow based on training data — not what is factually or contextually accurate. As a result the outputs are plausible-sounding but factually incorrect, logically inconsistent, or entirely fabricated. This is known as AI hallucination.

GenAI technologies can be misused, raising serious ethical concerns. Malicious actors can manipulate GenAI to automatically generate large volumes of misleading or false information that may influence public opinion, elections, or social unrest. This is generally encountered in creation of deepfake scripts, fake academic essays, or hate speech, particularly when guardrails are bypassed or weak. Excessive use of GenAI can lead to intellectual laziness and overreliance, especially among students or professionals who substitute critical thinking with machine assistance. Instead of engaging deeply with content, users might rely on AI to form arguments, solve problems, or write essays. This weakens the development of essential skills like analysis, synthesis, and creative thinking. As a result Users may begin to trust GenAI outputs without question a phenomenon known as automation bias even when the content is inaccurate or misleading. In the long run, reliance on AI-generated content without reflection can degrade research capabilities, writing proficiency, and cognitive development, especially in learning environments.

In conclusion generative AI has revolutionized the intellectual landscape by enhancing human creativity and critical thinking while simultaneously posing challenges to originality, authenticity, and legal frameworks. The intellectual capacity of humans is not necessarily diminished by GenAI, but it is redefined—dependent on how individuals and societies choose to engage with the technology. Balancing augmentation with autonomy, innovation with integrity, and automation with accountability is key. In the long run, thoughtful regulation and ethical AI practices are essential to ensure that intellectual property laws remain relevant and fair in a rapidly changing digital age.

References

Bender, E. M., Gebru, T., McMillan-Major, A., & Shmitchell, S. (2021). On the Dangers of Stochastic Parrots: Can Language Models Be Too Big?. FAccT.

Carr, N. (2010). The Shallows: What the Internet Is Doing to Our Brains. W. W. Norton & Company.

McCormack, J., Gifford, T., & Hutchings, P. (2020). Autonomy, Authenticity, and Authorship in AI-generated Art. Proceedings of ICCC.

OpenAI. (2023). GPT-4 Technical Report. https://openai.com/research/gpt-4

Thaler v. Perlmutter, No. 1:22-cv-01564 (D.D.C. 2023).

Getty Images (US), Inc. v. Stability AI, Inc., No. 1:23-cv-00135 (D. Del. 2023).

Outlier detection and handling in R

Naftali M — Tue, 29 Apr 2025 08:35:57 +0000

An outlier is a data point that significantly differs from other observations in a dataset. It can be:

- Unusually high or low compared to the rest of the data.
- Anomalous due to measurement errors, data entry mistakes, or rare events.
- A true extreme value that represents natural variation.

Example of data set

name of the loaded data is Data

How to identify outliers

basic summary function

summary(Data)

output

Visual methods (using Box plot)

Plot age on a box plot
boxplot(Data$Age, main = "Age",col = "skyblue")
output

Plot Net_worth on a box plot

boxplot(Data$Net_worth, main ="Networth in *10000 PLN",col = "orange")

output

Using interquatile range

Identify the outlier on age values

Q1 <- quantile(Data$Age, 0.25)
Q3 <- quantile(Data$Age, 0.75)
IQR <- Q3 - Q1
lower_bound_age <- Q1 - 1.5 * IQR
upper_bound_age <- Q3 + 1.5 * IQR
outlier_age <- Data$Age[Data$Age < lower_bound_age | Data$Age > upper_bound_age]
print(outlier_age)

output
93

Identify the outlier on Net_worth values

Q1 <- quantile(Data$Net_worth, 0.25)
Q3 <- quantile(Data$Net_worth, 0.75)
IQR <- Q3 - Q1
lower_bound_Net_worth <- Q1 - 1.5 * IQR
upper_bound_Net_worth <- Q3 + 1.5 * IQR
outlier_networth <- Data$Net_worth[Data$Net_worth < lower_bound_Net_worth | Data$Net_worth > upper_bound_Net_worth]
print(outlier_networth)

output
152000

SOLVING THE OUTLIER

Droping the outliers using the interquartile range

new_data <- Data[
  Data$Net_worth >= lower_bound_Net_worth & Data$Net_worth <= upper_bound_Net_worth &
  Data$Age >= lower_bound_age & Data$Age <= upper_bound_age, 
]

summary(new_data)

output

Substituting the outliers with column mean

identify the row index for outliers

# check the data row
which(Data$Net_worth== 152000 )
which(Data$Age== 93)

output
12, 10

Replace the outliers with the means

#Replace the data points with the mean
Data$Net_worth[12] <- mean(Data$Net_worth)
Data$Age[10] <- mean(Data$Age)
summary(Data)

plot the new data columns on a box plot

boxplot(Data$Age, 
        main = "Age", 
        col = "green", 
        border = "blue")

Output

boxplot(Data$Net_worth, 
        main = "Networth in *10000 PLN", 
        col = "yellow", 
        border = "blue")

output

USER REGISTRATION & AUTHENTICATION USING DJANGO.

Naftali M — Fri, 02 Aug 2024 14:31:58 +0000

This project will guide you through creating users using Django's default forms, registering users, authenticating users via the login form, and displaying certain pages only for authenticated users. You also can logout the user

Create project, and respective apps
Register your application in the settings.py file

INSTALLED_APPS = [
    'your_app', 
]

Create super user.

py manage.py createsuperuser

Create the template folder and have the following html pages
Base.html – contains all code that is extended to other html pages

`<!DOCTYPE html>
<html lang="en">
<head>
    <meta charset="UTF-8">
    <meta name="viewport" content="width=device-width, initial-scale=1.0">

    <title>User</title>
    <link href="https://cdn.jsdelivr.net/npm/bootstrap@5.3.3/dist/css/bootstrap.min.css" rel="stylesheet" integrity="sha384-QWTKZyjpPEjISv5WaRU9OFeRpok6YctnYmDr5pNlyT2bRjXh0JMhjY6hW+ALEwIH" crossorigin="anonymous">
<script src="https://cdn.jsdelivr.net/npm/bootstrap@5.3.3/dist/js/bootstrap.bundle.min.js" integrity="sha384-YvpcrYf0tY3lHB60NNkmXc5s9fDVZLESaAA55NDzOxhy9GkcIdslK1eN7N6jIeHz" crossorigin="anonymous"></script>
<link rel="stylesheet" href="#">
</head>
<body>
    <div class="container">
        <div class="card text-center mt-3">
            <div class="card-header">
              <ul class="nav nav-tabs card-header-tabs">
                <li class="nav-item">
                  <a class="nav-link "  href="#">Home</a>
                </li>
                <li class="nav-item">
                  <a class="nav-link "  href="{%url 'register'%}">Sign Up</a>
                </li>
                <li class="nav-item">
                  <a class="nav-link "  href="{%url 'signin'%}">Login</a>
                </li>
              </ul>
              <div class="card-body bg-info ">

                {% block content%}

                {%endblock%}
            </div>
            </div>
        </div>
    </div> 
</body>
</html>`

Home.html – contains code for our landing page

{%extends 'base.html'%}
{%block content%}
<h2>Welcome to user creation form</h2>
{%endblock%}

Register.html – contains code that renders the registration form
{%extends 'base.html'%}
{%block content%}
<h2>Registration Page</h2>
                 <form action="" method="post">
                    {% csrf_token %}
                    <!--1 {{form}}  Default django form -->
                     <!-- {{form.as_p}} -->

                    {{form.username.label}}{{form.username}}
                    <br>
                    {{form.email.label}} {{form.email}}
                    <br>
                    {{form.password1.label}} {{form.password1}}
                    <br>
                    {{form.password2.label}} {{form.password2}}
                    <br>
                    <!-- add bootstrap form controls here -->
                    <!-- <form >
                        <div class="form-group" style="width: 400px;">
                          <label for="formGroupExampleInput">username</label>
                          {{form.username}}
                        <br>
                          <label for="formGroupExampleInput2">Email</label>
                          {{form.email}}
                          <br>
                          <label for="formGroupExampleInput">password</label>
                          {{form.password1}}
                          <br>
                          <label for="formGroupExampleInput2">Confirm password</label>
                          {{form.password2}}
                        </div>
                      </form> -->
                    <input type="submit">
                    <!-- show any errors -->
                    {{form.errors}}

                    <p>Already have an account <a href="{%url 'signin'%}">Login</a></p>
                 </form>
{%endblock%}

Login page – contains code for the login interface

{%extends 'base.html'%}
{%block content%}
<p>Login form</p>
<form action="" method="POST">
    {% csrf_token %}
    <div class="form-group">
      <label for="">Username</label>
      <input type="text" class="form-control" id="" name="username" placeholder="Username">

      <label for="">password</label>
      <input type="password" class="form-control" id="" name="password" placeholder="password">

    </div>
    <input type="submit" value="submit">
    <p>Don't have an acccount <a href="{%url 'register'%}">Sign Up</a></p>

    <!-- display message -->
     {% for message in messages%}
        <p>{{message}}</p>

     {%endfor%}
  </form>
{%endblock%}

Form.py – this form helps us to override the basic Django user form and add our own email fields

from django.contrib.auth.forms import UserCreationForm
from django.contrib.auth.models import User
from django import forms

#custom user 
class CreateUserForm(UserCreationForm):
    class Meta:
        model = User
        fields = ['username', 'email', 'password1', 'password2']

urls.py – All our urls are registered to this file

from django.contrib import admin
from django.urls import path
from . import views
urlpatterns = [

   path("home/", views.home, name="home"),
   path("signin/", views.signin, name="signin"),
   path("register/", views.register, name="register"),
   path("dashboard/", views.dashboard, name="dashboard"),
   path("logout/", views.logout, name="logout"),
]

Views.py

from django.shortcuts import render, redirect
from django.http import HttpResponse
from .forms import CreateUserForm

#using messages
from django.contrib import messages
# handle login form
from django.contrib.auth import login, authenticate, logout
from django.contrib.auth.forms import UserCreationForm

#resctrict access to some pages 
from django.contrib.auth.decorators import login_required
def home(request):
    # return HttpResponse('Hello Learns!!!')
    return render(request, 'home.html')

def register(request):
    form = CreateUserForm()
    if request.method == 'POST':
        form = CreateUserForm(request.POST)
        if form.is_valid():
            form.save()
            #get username 
            user = form.cleaned_data.get('username')
            messages.success(request, 'Account succefully created for ' + user)
            # After user has registered take them to login page
            return redirect('signin')
    context = {'form': form}
    #return HttpResponse('Hello Learns!!!')
    return render(request, "register.html", context)

# def register(request):
#     form = UserCreationForm()
#     if request.method == 'POST':
#         form = UserCreationForm(request.POST)
#         if form.is_valid():
#             form.save()
#     context = {'form': form}
#     #return HttpResponse('Hello Learns!!!')
#     return render(request, "register.html", context)


# Create your views here.
def signin(request):
    if request.method == 'POST':
        username = request.POST.get('username')
        password = request.POST.get('password')

        user = authenticate(request, username=username, password=password)

        if user is not None:
            login(request, user)
            return redirect('dashboard')
        else:
            messages.info(request, 'Username or Password is incorrect')

    context = {}
    return render(request, 'login.html', context)

def logout(request): 
    return redirect('home')

@login_required(login_url='signin')
def dashboard(request):
    return render(request, 'dashboard.html')

To get the project code on github: Naftaly