How could I make a frame change colors smoothly without writing the different color3 values?

You can use interpolation
You actually have 2 options, which is RGB interpolation and HSL/HSV interpolation. Both have different results, so you should consider which one you want. HSL interpolation is proper, but RGB interpolation has less overhead at cost of quality.

RGB Interpolation

local function c3i(s,e,a)
	-- Start, end, alpha
	return Color3.new(s.r+(e.r-s.r)*a,s.g+(e.g-s.g)*a,s.b+(e.b-s.b)*a);
end;
local i = 0;
local TimeScale = TIMETOFINISHINSECONDS ^-1;
while i < 1 do
	Object.Color3Property = c3i(StartColor3, EndColor3, i);
	i = i + wait()*TimeScale;
end;

HSL Interpolation

Please excuse the util functions and size of the code

local function hue2rgb(p, q, t)
	if t < 0 then t = t + 1; end
	if t > 1 then t = t - 1; end
	if t < 1 / 6 then return p + (q - p) * 6 * t; end
	if t < .5 then return q; end
	if t < 2 / 3 then return p + (q - p) * (2 / 3 - t) * 6; end
	return p;
end
local hsl = function(H,S,L)
	H = max(min(1,H),0);
	S = max(min(1,S),0);
	L = max(min(1,L),0);
	local c = H..":"..S..":"..L;
	if S == 0 then
		return Color3.new(L,L,L);
	else
		local q = L < 0.5 and L * (1 + S) or L + S - L * S;
		local p = 2 * L - q;
		local nc3 = Color3.new(hue2rgb(p, q, H + 1 / 3),
			hue2rgb(p, q, H),
			hue2rgb(p, q, H - 1 / 3))
		return nc3;
	end
end;
local hsli(s,e,a)
	local r,g,b,dr,dg,db;
	do
		r = s.r;
		g,dr = s.g,e.r;
		b,dg = s.b,e.g;
		db = e.b
	end
	do
		local tsmin, tsmax = min(r,g,b), max(r,g,b);
		local _r,_g,_b = r,g,b;
		local _dr,_dg,_db = dr,dg,db;
		local tdmin, tdmax = min(dr,dg,db), max(dr,dg,db);
		b = (tsmin + tsmax)*.5;
		db = (tdmin + tdmax)*.5;
		g = tsmin == tsmax and 0 or (b < 0.5 and (tsmax-tsmin)/(tsmax+tsmin) or (tsmax-tsmin)/(2-tsmax-tsmin))
		dg = tdmin == tdmax and 0 or (db < 0.5 and (tdmax-tdmin)/(tdmax+tdmin) or (tdmax-tdmin)/(2-tdmax-tdmin))
		if _r>_g and _r>_b then
			r = (_g-_b)/(tsmax-tsmin)
		elseif _g>_r and _g>_b then
			r = 2+(_b-_r)/(tsmax-tsmin)
		else
			r = 4+(_r-_g)/(tsmax-tsmin);
		end;
		if _dr>_dg and _dr>_db then
			dr = (_dg-_db)/(tsmax-tsmin)
		elseif _dg>_dr and _dg>_db then
			dr = 2+(_db-_dr)/(tsmax-tsmin)
		else
			dr = 4+(_dr-_dg)/(tsmax-tsmin);
		end;
		r,dr = r/6, dr/6;
		if r < 0 then r = r+1 end;
		if dr < 0 then dr = dr+1 end;
	end
	dr,dg,db = dr-r,dg-g,db-b;
	return hsl(r+dr*a,g+dg*a,b+db*a)
end
local i = 0;
local TimeScale = TIMETOFINISHINSECONDS ^-1;
while i < 1 do
	Object.Color3Property = hsli(StartColor3, EndColor3, i);
	i = i + wait()*TimeScale;
end;

Source

Instructions

To use it, just change (at the bottom of each script) these variables

• TIMETOFINISHINSECONDS - The time to finish tweening, in seconds.
• Object - The object you're going to be changing the colour of
• Color3Property - The name of the property that you're going to be tweening
• StartColor3 - The initial Color3 to tween from
• EndColor3 - The final Color3 to tween to

How does it work?

Both methods for RGB and HSL use linear interpolation, which comes down to lerp(start,end,alpha) -> start + (end-start)*alpha.
RGB tweening uses a simple 1:1 conversion of the Color3 to its components, back into a Color3.
HSL tweening uses a bunch of formulas to convert the start and end Color3 values to HSL, interpolates them linearly and then uses similar formulas to convert the HSL values back to RGB which is fed into the Color3 constructor.